LISP - Revision history

Jerry at 13:45, 11 February 2023

2023-02-11T13:45:01Z

← Older revision		Revision as of 06:45, 11 February 2023
Line 182:		Line 182:
	=== Problem 1 ===		=== Problem 1 ===

	Evaluate the following expression. <code>(MULT (ADD 6 5 0) (MULT 5 1 2 2) (DIV 9 (SUB 2 5)))</code>		Evaluate the following expression. <code>(MULT (ADD 6 5 0) (MULT 5 1 2 2) (DIV 6 (SUB 2 5)))</code>

	'''Solution:'''		'''Solution:'''

Williamhu: Fixed inconsistencies with curly/straight quotes

2019-07-15T00:07:02Z

Fixed inconsistencies with curly/straight quotes

← Older revision		Revision as of 17:07, 14 July 2019
Line 1:		Line 1:
	LISP is one of the simplest computer languages in terms of syntax and semantics, and also one of the most powerful. It was developed in the mid-~~1950’s~~ by John McCarthy at M.I.T. as a ~~“LISt~~ Processing language.” It has been historically used for virtually all Artificial Intelligence programs and is often the environment of choice for applications which require a powerful interactive working environment. LISP presents a very different way to think about programming from the ~~“algorithmic”~~ languages, such as Python, C++, and Java.		LISP is one of the simplest computer languages in terms of syntax and semantics, and also one of the most powerful. It was developed in the mid-1950's by John McCarthy at M.I.T. as a "LISt Processing language." It has been historically used for virtually all Artificial Intelligence programs and is often the environment of choice for applications which require a powerful interactive working environment. LISP presents a very different way to think about programming from the "algorithmic" languages, such as Python, C++, and Java.

	== Syntax ==		== Syntax ==
Line 13:		Line 13:
	== Basic Functions (SET, SETQ, EVAL, ATOM) ==		== Basic Functions (SET, SETQ, EVAL, ATOM) ==

	We may assign values to variables using the function SET. For example, the statement (SET ~~’test~~ 6) would have a value of a 6, and (more importantly, however) would also cause the atom ~~‘test~~ to be bound to the atom 6. The function SETQ is the same as SET, but it causes LISP to act as if the first argument was quoted.		We may assign values to variables using the function SET. For example, the statement (SET 'test 6) would have a value of a 6, and (more importantly, however) would also cause the atom 'test to be bound to the atom 6. The function SETQ is the same as SET, but it causes LISP to act as if the first argument was quoted.
	Observe the following examples:		Observe the following examples:

Line 19:		Line 19:
	!Statement \|\| Value \|\| Comment		!Statement \|\| Value \|\| Comment
	\|-		\|-
	\|(SET ’a (MULT 2 3))		\|(SET 'a (MULT 2 3))
	\|6		\|6
	\|a is an atom with a value of 6		\|a is an atom with a value of 6
	\|-		\|-
	\|(SET ~~’a ’~~(MULT 2 3))		\|(SET 'a '(MULT 2 3))
	\|(MULT 2 3)		\|(MULT 2 3)
	\|a is a list with 3 elements		\|a is a list with 3 elements
	\|-		\|-
	\|(SET ~~’b ’a~~)		\|(SET 'b 'a)
	\|a		\|a
	\|b is an atom with a value of the character a		\|b is an atom with a value of the character a
	\|-		\|-
	\|(SET ’c a)		\|(SET 'c a)
	\|(MULT 2 3)		\|(MULT 2 3)
	\|c is a list with 3 elements		\|c is a list with 3 elements
Line 39:		Line 39:
	\|The variable EX has a value of 13		\|The variable EX has a value of 13
	\|-		\|-
	\|(SETQ VOWELS ’(A E I O U))		\|(SETQ VOWELS '(A E I O U))
	\|(A E I O U)		\|(A E I O U)
	\|VOWELS is a list of 5 elements		\|VOWELS is a list of 5 elements
	\|}		\|}

	The function EVAL returns the value of its argument, after it has been evaluated. For example, (SETQ z ’(ADD 2 3)) has a value of the list (ADD 2 3); the function (EVAL ’z) has a value of (ADD 2 3); the function (EVAL z) has a value of 5 (but the binding of the atom z has not changed). In this last example, you can think of z being ~~“resolved”~~ twice: once because it is an argument to a function and LISP evaluates all arguments to functions before the function is invoked, and once when the function EVAL is invoked to resolve arguments. The function ATOM can be used to determine whether an item is an atom or a list. It returns either "true", or "NIL" for false. Consider the following examples:		The function EVAL returns the value of its argument, after it has been evaluated. For example, (SETQ z '(ADD 2 3)) has a value of the list (ADD 2 3); the function (EVAL 'z) has a value of (ADD 2 3); the function (EVAL z) has a value of 5 (but the binding of the atom z has not changed). In this last example, you can think of z being "resolved" twice: once because it is an argument to a function and LISP evaluates all arguments to functions before the function is invoked, and once when the function EVAL is invoked to resolve arguments. The function ATOM can be used to determine whether an item is an atom or a list. It returns either "true", or "NIL" for false. Consider the following examples:

	:{\| class="wikitable" style="text-align: left"		:{\| class="wikitable" style="text-align: left"
Line 68:		Line 68:
	== List Functions (CAR, CDR, CONS, REVERSE)==		== List Functions (CAR, CDR, CONS, REVERSE)==

	The two most famous LISP functions are CAR and CDR (pronounced: could-er), named after registers of a now long-forgotten IBM machine on which LISP was first developed. The function (CAR x) returns the first item of the list x (and x must be a list or an error will occur); (CDR x) returns the list without its first element (again, x must be a list). The function CONS takes two arguments, of which the second must be a list. It returns a list which is composed by placing the first argument as the first element in the second ~~argument’s~~ list. The function REVERSE returns a list which is its arguments in reverse order.		The two most famous LISP functions are CAR and CDR (pronounced: could-er), named after registers of a now long-forgotten IBM machine on which LISP was first developed. The function (CAR x) returns the first item of the list x (and x must be a list or an error will occur); (CDR x) returns the list without its first element (again, x must be a list). The function CONS takes two arguments, of which the second must be a list. It returns a list which is composed by placing the first argument as the first element in the second argument's list. The function REVERSE returns a list which is its arguments in reverse order.

	The CAR and CDR functions are used extensively to grab specific elements of a list or sublist, that there's a shorthand for this: (CADR x) is the same as (CAR (CDR x)), which retrieves the second element of the list x; (CAADDAR x) is a shorthand for (CAR (CAR (CDR (CDR (CAR x))))), and so on.		The CAR and CDR functions are used extensively to grab specific elements of a list or sublist, that there's a shorthand for this: (CADR x) is the same as (CAR (CDR x)), which retrieves the second element of the list x; (CAADDAR x) is a shorthand for (CAR (CAR (CDR (CDR (CAR x))))), and so on.
Line 98:		Line 98:
	== Arithmetic Functions (ADD, MULT, ...)==		== Arithmetic Functions (ADD, MULT, ...)==

	As you have probably already figured out, the function ADD simply summed its arguments. ~~We’ll~~ also be using the following arithmetic functions:		As you have probably already figured out, the function ADD simply summed its arguments. We'll also be using the following arithmetic functions:

	:{\| class="wikitable" style="text-align: left"		:{\| class="wikitable" style="text-align: left"
Line 151:		Line 151:
	LISP also allows us to create our own functions using the DEF function. (We will sometimes use DEFUN rather than DEF, as it is a bit more standard terminology.) For example,		LISP also allows us to create our own functions using the DEF function. (We will sometimes use DEFUN rather than DEF, as it is a bit more standard terminology.) For example,
	(DEF SECOND (args) (CAR (CDR args)))		(DEF SECOND (args) (CAR (CDR args)))
	defines a new function called SECOND which operates on a single parameter named ~~“args”~~. SECOND will take the CDR of the parameter and then the CAR of that result. So, for example:		defines a new function called SECOND which operates on a single parameter named "args". SECOND will take the CDR of the parameter and then the CAR of that result. So, for example:
	(SECOND ’(a b c d e))		(SECOND '(a b c d e))
	would first CDR the list to give (b c d e), and then CAR that value returning the single character ~~“b”~~. Consider the following program fragment:		would first CDR the list to give (b c d e), and then CAR that value returning the single character "b". Consider the following program fragment:
	(SETQ X ’(a c s l))		(SETQ X '(a c s l))
	(DEF WHAT(args) (CONS args (REVERSE (CDR args))))		(DEF WHAT(args) (CONS args (REVERSE (CDR args))))
	(DEF SECOND(args) (CONS (CAR (CDR args)) NIL))		(DEF SECOND(args) (CONS (CAR (CDR args)) NIL))
Line 192:		Line 192:
	=== Problem 2 ===		=== Problem 2 ===

	Evaluate the following expression: <code>(CDR ’((2 (3))(4 (5 6) 7)))</code>		Evaluate the following expression: <code>(CDR '((2 (3))(4 (5 6) 7)))</code>

	'''Solution:'''		'''Solution:'''
Line 201:		Line 201:

	Consider the following program fragment:		Consider the following program fragment:
	(SETQ X ’(RI VA FL CA TX))		(SETQ X '(RI VA FL CA TX))
	(CAR (CDR (REVERSE X)))		(CAR (CDR (REVERSE X)))
	What is the value of the CAR expression?		What is the value of the CAR expression?

	'''Solution:'''		'''Solution:'''
	The first statement binds variable X to the list ‘(RI VA FL CA TX).		The first statement binds variable X to the list '(RI VA FL CA TX).
	The REVERSE of this list is ‘(TX CA FL VA RI)		The REVERSE of this list is '(TX CA FL VA RI)
	whose CDR is ‘(CA FL VA RI). The CAR of this list is just the atom CA (without the quote).		whose CDR is '(CA FL VA RI). The CAR of this list is just the atom CA (without the quote).

	<!--		<!--
Line 220:		Line 220:
	(DEFUN FY(PARM) (CAR (HY (CDR PARM))))		(DEFUN FY(PARM) (CAR (HY (CDR PARM))))
	What is the value of the following?		What is the value of the following?
	(FY ’(DO RE (MI FA) SO))		(FY '(DO RE (MI FA) SO))

	'''Solution:'''		'''Solution:'''
	To evaluate (FY ’(DO RE (MI FA) SO)), we must evaluate		To evaluate (FY '(DO RE (MI FA) SO)), we must evaluate
	(CAR (HY (CDR ’(DO RE (MI FA) SO)))).		(CAR (HY (CDR '(DO RE (MI FA) SO)))).
	Thus, HY is invoked with		Thus, HY is invoked with
	PARM = ’(RE (MI FA) SO), and we evaluate		PARM = '(RE (MI FA) SO), and we evaluate
	(REVERSE (CDR ’(RE (MI FA) SO)))		(REVERSE (CDR '(RE (MI FA) SO)))
	This has a value of (SO (MI FA)) which is returned to FY. FY now takes the CAR of this which is SO (without the quotes).		This has a value of (SO (MI FA)) which is returned to FY. FY now takes the CAR of this which is SO (without the quotes).
	-->		-->

Marc: /* Basic Functions (SET, SETQ, EVAL, ATOM) */

2019-04-16T17:21:02Z

Basic Functions (SET, SETQ, EVAL, ATOM)

← Older revision		Revision as of 10:21, 16 April 2019
Line 19:		Line 19:
	!Statement \|\| Value \|\| Comment		!Statement \|\| Value \|\| Comment
	\|-		\|-
	\|(SET ’a ( MULT 2 3))		\|(SET ’a (MULT 2 3))
	\|6		\|6
	\|a is an atom with a ~~vaue~~ of 6		\|a is an atom with a value of 6
	\|-		\|-
	\|(SET ’a ’(MULT 2 3))		\|(SET ’a ’(MULT 2 3))

Williamhu: /* User-defined Functions */ code box

2019-01-23T20:19:30Z

User-defined Functions: code box

← Older revision		Revision as of 13:19, 23 January 2019
Line 154:		Line 154:
	(SECOND ’(a b c d e))		(SECOND ’(a b c d e))
	would first CDR the list to give (b c d e), and then CAR that value returning the single character “b”. Consider the following program fragment:		would first CDR the list to give (b c d e), and then CAR that value returning the single character “b”. Consider the following program fragment:
	:(SETQ X ’(a c s l))		(SETQ X ’(a c s l))
	:(DEF WHAT(args) (CONS args (REVERSE (CDR args))))		(DEF WHAT(args) (CONS args (REVERSE (CDR args))))
	:(DEF SECOND(args) (CONS (CAR (CDR args)) NIL))		(DEF SECOND(args) (CONS (CAR (CDR args)) NIL))

	The following chart illustrates the use of the user-defined functions WHAT and SECOND:		The following chart illustrates the use of the user-defined functions WHAT and SECOND:

Williamhu: /* Syntax */ Replaced curly quotes with vertical ones

2019-01-21T15:30:31Z

Syntax: Replaced curly quotes with vertical ones

← Older revision		Revision as of 08:30, 21 January 2019
Line 7:		Line 7:
	:<code>(23 (this is easy) hello 821)</code>		:<code>(23 (this is easy) hello 821)</code>

	The elements in the list, which are not lists, are called ~~“atoms~~.” For example, the atoms in the list above are: 23, ~~‘this~~, ~~‘hello~~, 821, ~~‘easy~~, and ~~‘is~~. Literals are identified with a single leading quote. Everything in LISP is either an atom or a list (but not both). The only exception is ~~“NIL~~,” which is both an atom and a list. It can also be written as “()” – a pair of parentheses with nothing inside.		The elements in the list, which are not lists, are called "atoms." For example, the atoms in the list above are: 23, 'this, 'hello, 821, 'easy, and 'is. Literals are identified with a single leading quote. Everything in LISP is either an atom or a list (but not both). The only exception is "NIL," which is both an atom and a list. It can also be written as "()" – a pair of parentheses with nothing inside.

	All statements in LISP are function calls with the following syntax: (function arg1 arg2 arg3 … argn). To evaluate a LISP statement, each of the arguments (possibly functions themselves) are evaluated, and then the function is invoked with the arguments. For example, (MULT (ADD 2 3) (ADD 1 4 2)) has a value of 35, since (ADD 2 3) has a value of 5, (ADD 1 4 2) has a value of 7, and (MULT 5 7) has a value of 35. Some functions have an arbitrary number of arguments; others require a fixed number. All statements return a value, which is either an atom or a list.		All statements in LISP are function calls with the following syntax: (function arg1 arg2 arg3 … argn). To evaluate a LISP statement, each of the arguments (possibly functions themselves) are evaluated, and then the function is invoked with the arguments. For example, (MULT (ADD 2 3) (ADD 1 4 2)) has a value of 35, since (ADD 2 3) has a value of 5, (ADD 1 4 2) has a value of 7, and (MULT 5 7) has a value of 35. Some functions have an arbitrary number of arguments; others require a fixed number. All statements return a value, which is either an atom or a list.

	== Basic Functions (SET, SETQ, EVAL, ATOM) ==		== Basic Functions (SET, SETQ, EVAL, ATOM) ==

Williamhu: /* List Functions (CAR, CDR, CONS, REVERSE) */ Removed extra parentheses and different quotes

2019-01-21T03:29:40Z

List Functions (CAR, CDR, CONS, REVERSE): Removed extra parentheses and different quotes

← Older revision		Revision as of 20:29, 20 January 2019
Line 77:		Line 77:
	!Statement \|\| Value		!Statement \|\| Value
	\|-		\|-
	\|(CAR ’(This is a list))		\|(CAR '(This is a list))
	\|This		\|This
	\|-		\|-
	\|(CDR ’(This is a list)))		\|(CDR '(This is a list))
	\|(is a list)		\|(is a list)
	\|-		\|-
Line 86:		Line 86:
	\|(red white blue)		\|(red white blue)
	\|-		\|-
	\|(SETQ z (CONS '(red white blue) (CDR ’(This is a list)))))		\|(SETQ z (CONS '(red white blue) (CDR '(This is a list))))
	\|((red white blue) is a list)		\|((red white blue) is a list)
	\|-		\|-

Williamhu: /* Problem 3 */ Tried to fix syntaxhighlight

2019-01-09T22:41:05Z

Problem 3: Tried to fix syntaxhighlight

← Older revision		Revision as of 15:41, 9 January 2019
Line 201:		Line 201:

	Consider the following program fragment:		Consider the following program fragment:
	~~<syntaxhighlight>~~		(SETQ X ’(RI VA FL CA TX))
	(SETQ X ’(RI VA FL CA TX))		(CAR (CDR (REVERSE X)))
	(CAR (CDR (REVERSE X)))
	~~</syntaxhighlight>~~
	What is the value of the CAR expression?		What is the value of the CAR expression?

Marc Brown: /* Basic Functions (SET, SETQ, EVAL, ATOM) */

2019-01-09T08:29:07Z

Basic Functions (SET, SETQ, EVAL, ATOM)

← Older revision		Revision as of 01:29, 9 January 2019
Line 55:		Line 55:
	\|(ATOM 'p)		\|(ATOM 'p)
	\|true		\|true
	\|The argument to ATOM is the ~~ato~~ p		\|The argument to ATOM is the atom p
	\|-		\|-
	\|(ATOM p)		\|(ATOM p)

Marc Brown: /* Sample Problems */

2018-09-09T09:36:41Z

Sample Problems

← Older revision		Revision as of 02:36, 9 September 2018
Line 180:		Line 180:
	Questions from this topic will typically present a line of LISP code or a short sequence of statements and ask what is the value of the (final) statement.		Questions from this topic will typically present a line of LISP code or a short sequence of statements and ask what is the value of the (final) statement.

	=== ~~Sample~~ Problem 1 ===		=== Problem 1 ===

	Evaluate the following expression. <code>(MULT (ADD 6 5 0) (MULT 5 1 2 2) (DIV 9 (SUB 2 5)))</code>		Evaluate the following expression. <code>(MULT (ADD 6 5 0) (MULT 5 1 2 2) (DIV 9 (SUB 2 5)))</code>
Line 190:		Line 190:
	-440		-440

	=== ~~Sample~~ Problem 2 ===		=== Problem 2 ===

	Evaluate the following expression: <code>(CDR ’((2 (3))(4 (5 6) 7)))</code>		Evaluate the following expression: <code>(CDR ’((2 (3))(4 (5 6) 7)))</code>
Line 198:		Line 198:
	((4 (5 6) 7)), a list with one element.		((4 (5 6) 7)), a list with one element.

	=== ~~Sample~~ Problem 3 ===		=== Problem 3 ===

	Consider the following program fragment:		Consider the following program fragment:
Line 216:		Line 216:
	Too scary of a sample problem! --marc 9/3/2018		Too scary of a sample problem! --marc 9/3/2018

	=== ~~Sample~~ Problem 4 ===		=== Problem 4 ===

	Given the function definitions for HY and FY as follows:		Given the function definitions for HY and FY as follows:

Carlen: /* List Functions (CAR, CDR, CONS, REVERSE) */

2018-09-07T10:50:50Z

List Functions (CAR, CDR, CONS, REVERSE)

← Older revision		Revision as of 03:50, 7 September 2018
Line 90:		Line 90:
	\|-		\|-
	\|(REVERSE z)		\|(REVERSE z)
	\|(list a is ~~this~~ (red white blue))		\|(list a is (red white blue))
	\|-		\|-
	\|(CDDAR z)		\|(CDDAR z)