นับตั้งแต่เริ่มแรก Lisp มีความเชื่อมโยงอย่างใกล้ชิดกับ ชุมชนวิจัย ปัญญาประดิษฐ์โดยเฉพาะอย่างยิ่งบน ระบบ PDP-10 ^{[ 23 ]} Lisp ถูกใช้เป็นการนำภาษาMicro Planner มาใช้ ซึ่งใช้ในระบบ AI ชื่อดังอย่างSHRDLUในช่วงทศวรรษ 1970 เมื่อการวิจัย AI ก่อให้เกิดสาขาเชิงพาณิชย์ ประสิทธิภาพของระบบ Lisp ที่มีอยู่จึงกลายเป็นปัญหาที่เพิ่มมากขึ้น เนื่องจากโปรแกรมเมอร์จำเป็นต้องคุ้นเคยกับผลกระทบด้านประสิทธิภาพของเทคนิคและตัวเลือกต่างๆ ที่เกี่ยวข้องกับการนำ Lisp มาใช้^{[ 24 ]}

ตลอดระยะเวลากว่าหกสิบปี ภาษา Lisp ได้ก่อให้เกิดรูปแบบต่างๆ มากมายบนพื้นฐานหลักของภาษา S-expression บางรูปแบบได้รับการกำหนดมาตรฐานและนำไปใช้งานโดยกลุ่มต่างๆ ที่มีลำดับความสำคัญแตกต่างกัน (ตัวอย่างเช่นCommon LispและSchemeมีหลายเวอร์ชัน) อย่างไรก็ตาม ในบางกรณี โครงการซอฟต์แวร์กำหนดภาษา Lisp โดยไม่มีมาตรฐาน และไม่มีการแบ่งแยกที่ชัดเจนระหว่างภาษาถิ่นและการใช้งาน (ตัวอย่างเช่นClojureและEmacs Lispจัดอยู่ในประเภทนี้)

ความแตกต่างระหว่างภาษาถิ่น (และ/หรือการใช้งาน) อาจเห็นได้ชัดเจน—ตัวอย่างเช่น Common Lisp ใช้คำหลักdefunในการตั้งชื่อฟังก์ชัน แต่ Scheme ใช้define[ ^{หมายเหตุ 2 ]}ภายในภาษาถิ่นที่เป็นมาตรฐาน การใช้งานที่สอดคล้องกับมาตรฐานจะรองรับภาษาหลักเดียวกัน แต่มีส่วนขยายและไลบรารีที่แตกต่างกัน บางครั้งสิ่งนี้ก็สร้างการเปลี่ยนแปลงที่เห็นได้ชัดเจนจากภาษาพื้นฐาน—ตัวอย่างเช่นGuile (การใช้งาน Scheme) ใช้define*เพื่อสร้างฟังก์ชันที่มีอาร์กิวเมนต์เริ่มต้นและ/หรืออาร์กิวเมนต์คำหลักซึ่งทั้งสองอย่างนี้ไม่ได้เป็นมาตรฐาน

ภาษาถิ่นที่มีความสำคัญทางประวัติศาสตร์

• LISP 1 ^{[ 25 ]} – การใช้งานครั้งแรก
• LISP 1.5 ^{[ 26 ]} – เวอร์ชันที่เผยแพร่อย่างกว้างขวางครั้งแรก พัฒนาโดย McCarthy และคนอื่นๆ ที่ MIT ได้รับการตั้งชื่อเช่นนี้เพราะมีการปรับปรุงหลายอย่างจากตัวแปล "LISP 1" ดั้งเดิม แต่ไม่ใช่การปรับโครงสร้างครั้งใหญ่เหมือนLISP 2 ที่วางแผนไว้
• Stanford LISP 1.6 ^{[ 27 ]} – เป็นรุ่นต่อจาก LISP 1.5 ที่พัฒนาที่Stanford AI Labและเผยแพร่อย่างกว้างขวางไปยังระบบPDP-10 ที่ใช้ระบบปฏิบัติการ TOPS-10 ต่อ มา Maclisp และ InterLisp ก็ทำให้ LISP ล้าสมัยไป
• Maclisp ^{[ 28 ]} – พัฒนาขึ้นสำหรับ โครงการ MACของ MIT , MACLISP เป็นทายาทโดยตรงของ LISP 1.5 ทำงานบนระบบ PDP-10 และMulticsต่อมา MACLISP จะถูกเรียกว่า Maclisp และมักถูกเรียกว่า MacLisp คำว่า "MAC" ใน MACLISP ไม่เกี่ยวข้องกับMacintosh ของ Apple หรือMcCarthy
• Interlisp ^{[ 29 ]} – พัฒนาที่BBN Technologiesสำหรับระบบ PDP-10 ที่ใช้ระบบปฏิบัติการ TENEXต่อมาได้รับการยอมรับเป็น Lisp "West coast" สำหรับเครื่อง Xerox Lisp ในชื่อ InterLisp-D เวอร์ชันขนาดเล็กที่เรียกว่า "InterLISP 65" ได้รับการเผยแพร่สำหรับคอมพิวเตอร์ Atari 8 บิตที่ใช้MOS Technology 6502 Maclisp และ InterLisp เป็นคู่แข่งที่แข็งแกร่ง
• Franz Lisp – เดิมทีเป็น โครงการ ของมหาวิทยาลัยแคลิฟอร์เนีย เบิร์กลีย์ต่อมาได้รับการพัฒนาโดย Franz Inc. ชื่อนี้เป็นการดัดแปลงชื่อ " Franz Liszt " ในเชิงขำขัน และไม่ได้หมายถึงAllegro Common Lispซึ่งเป็นภาษาถิ่นของ Common Lisp ที่ Franz Inc. จำหน่ายในภายหลัง
• muLISP – พัฒนาขึ้นครั้งแรกโดย Albert D. Rich และ David Stoutemeyer สำหรับระบบไมโครคอมพิวเตอร์ขนาดเล็ก วางจำหน่ายเชิงพาณิชย์ในปี 1979 โดยทำงานบนระบบ CP/M ที่มี RAM เพียง 64KB และต่อมาได้พอร์ตไปยัง MS-DOS การพัฒนาเวอร์ชัน MS-DOS สิ้นสุดลงในปี 1995 ซอฟต์แวร์ทางคณิตศาสตร์ "Derive" เขียนด้วย muLISP สำหรับ MS-DOS และต่อมาสำหรับ Windows จนถึงปี 2007
• XLISPซึ่งเป็นพื้นฐานของAutoLISP
• Standard LispและPortable Standard Lispได้รับการใช้งานและพอร์ตอย่างแพร่หลาย โดยเฉพาะอย่างยิ่งกับระบบพีชคณิตคอมพิวเตอร์ REDUCE
• ZetaLispหรือเรียกอีกอย่างว่า Lisp Machine Lisp – ภาษาที่ใช้บนเครื่อง Lispเป็นภาษาที่สืบทอดมาจาก Maclisp โดยตรง ZetaLisp มีอิทธิพลอย่างมากต่อ Common Lisp
• LeLispเป็นภาษาถิ่น Lisp ของฝรั่งเศส หนึ่งในตัวสร้างอินเทอร์เฟซ ตัวแรก (เรียกว่า SOS Interface ^{[ 30 ]} ) เขียนด้วย LeLisp
• แผน (พ.ศ. 2518) ^{[ 31 ]}
• Common Lisp (1984) ตามที่อธิบายไว้ในCommon Lisp the Language – เป็นการรวมความพยายามที่แตกต่างกันหลายประการ (ZetaLisp, Spice Lisp , NILและS-1 Lisp ) เพื่อสร้างภาษาถิ่นที่สืบทอดต่อ จาก Maclisp ^{[ 32 ]}โดยได้รับอิทธิพลจากภาษาถิ่น Scheme ด้วยเช่นกัน Common Lisp เวอร์ชันนี้สามารถใช้งานได้บนแพลตฟอร์มที่หลากหลายและได้รับการยอมรับจากหลายคนว่าเป็นมาตรฐานโดยพฤตินัย^{[ 33 ]}จนกระทั่งมีการเผยแพร่ ANSI Common Lisp (ANSI X3.226-1994) ภาษาถิ่นย่อยที่แพร่หลายที่สุดของ Common Lisp ได้แก่Steel Bank Common Lisp (SBCL), CMU Common Lisp (CMU-CL), Clozure OpenMCL (อย่าสับสนกับ Clojure!), GNU CLisp และ Franz Lisp เวอร์ชันต่อมา ทั้งหมดนี้เป็นไปตามมาตรฐาน ANSI CL ในภายหลัง (ดูด้านล่าง)
• ในเวอร์ชันแรก Dylanเป็นการผสมผสานระหว่าง Scheme กับ Common Lisp Object System
• EuLisp – ความพยายามในการพัฒนาภาษา Lisp รูปแบบใหม่ที่มีประสิทธิภาพและสะอาดตามากขึ้น
• ISLISP – ความพยายามในการพัฒนา Lisp ที่มีประสิทธิภาพและสะอาดขึ้นใหม่ ได้รับการกำหนดมาตรฐานเป็น ISO/IEC 13816:1997 ^{[ 34 ]}และต่อมาได้รับการแก้ไขเป็น ISO/IEC 13816:2007: ^{[ 35 ]}เทคโนโลยีสารสนเทศ – ภาษาโปรแกรม สภาพแวดล้อม และอินเทอร์เฟซซอฟต์แวร์ระบบ – ภาษาโปรแกรม ISLISP
• รูปแบบ IEEE – มาตรฐาน IEEE, 1178–1990 (R1995)
• ANSI Common Lisp – มาตรฐานAmerican National Standards Institute (ANSI) สำหรับ Common Lisp ซึ่งสร้างขึ้นโดยคณะอนุกรรมการX3J13ได้รับมอบหมาย^{[ 36 ]}ให้เริ่มต้นด้วยCommon Lisp: The Languageเป็นเอกสารพื้นฐาน และดำเนินการผ่าน กระบวนการ ฉันทามติ สาธารณะ เพื่อหาแนวทางแก้ไขปัญหาร่วมกันเกี่ยวกับการพกพาโปรแกรมและความเข้ากันได้ของการใช้งาน Common Lisp แม้ว่าจะเป็นมาตรฐาน ANSI อย่างเป็นทางการ แต่การนำไปใช้ การขาย การใช้งาน และอิทธิพลของ ANSI Common Lisp ก็มีให้เห็นและยังคงพบเห็นได้ทั่วโลก
• ACL2หรือ "A Computational Logic for Applicative Common Lisp" เป็นภาษาโปรแกรมแบบประยุกต์ (ปราศจากผลข้างเคียง) ที่พัฒนามาจาก Common LISP ACL2 เป็นทั้งภาษาโปรแกรมที่สามารถจำลองระบบคอมพิวเตอร์ และเป็นเครื่องมือช่วยพิสูจน์คุณสมบัติของแบบจำลองเหล่านั้น
• Clojureเป็นภาษา Lisp สายพันธุ์ใหม่ที่คอมไพล์เป็นJava virtual machineและเน้นเรื่องการทำงานพร้อมกัน เป็น พิเศษ
• Game Oriented Assembly Lisp (หรือ GOAL) เป็นภาษาโปรแกรมสำหรับวิดีโอเกมที่พัฒนาโดยAndy GavinจากNaughty Dogโดยเขียนขึ้นโดยใช้ Allegro Common Lisp และถูกนำไปใช้ในการพัฒนาเกมซีรีส์ Jak and Daxter ทั้งหมด ที่พัฒนาโดย Naughty Dog

หลังจากที่ความสนใจในภาษา Lisp ลดลงบ้างในช่วงทศวรรษ 1990 ความสนใจก็กลับมาเพิ่มขึ้นอีกครั้งหลังปี 2000 กิจกรรมใหม่ส่วนใหญ่เน้นไปที่การใช้งานCommon Lisp , Scheme , Emacs Lisp , ClojureและRacketรวมถึงการพัฒนาไลบรารีและแอปพลิเคชันแบบพกพาใหม่ๆ ด้วย

โปรแกรมเมอร์ Lisp รุ่นใหม่จำนวนมากได้รับแรงบันดาลใจจากนักเขียนเช่นPaul GrahamและEric S. Raymondให้หันมาใช้ภาษาที่คนอื่นมองว่าล้าสมัย โปรแกรมเมอร์ Lisp รุ่นใหม่มักอธิบายว่าภาษานี้เป็นประสบการณ์ที่เปิดโลกทัศน์และอ้างว่ามีประสิทธิภาพมากกว่าภาษาอื่นๆ อย่างมาก^{[ 37 ]}การเพิ่มขึ้นของความตระหนักนี้อาจเปรียบเทียบได้กับ " ฤดูหนาวของ AI " และความนิยมของ Lisp ในช่วงกลางทศวรรษ 1990 ^{[ 38 ]}

ข้อมูล ณ ปี 2010มีการใช้งาน Common Lisp ที่ได้รับการดูแลรักษาอย่างต่อเนื่องจำนวน 11 รายการ^{[ 39 ]}

ชุมชนโอเพนซอร์สได้สร้างโครงสร้างพื้นฐานสนับสนุนใหม่: CLikiเป็นวิกิที่รวบรวมข้อมูลที่เกี่ยวข้องกับ Common Lisp, ไดเร็กทอรี Common Lisp แสดงรายการทรัพยากร, #lisp เป็นช่อง IRC ยอดนิยมและอนุญาตให้แบ่งปันและแสดงความคิดเห็นเกี่ยวกับโค้ดตัวอย่าง (โดยได้รับการสนับสนุนจาก lisppaste ซึ่งเป็นบอท IRCที่เขียนด้วย Lisp), Planet Lisp ^{[ 40 ]}รวบรวมเนื้อหาของบล็อกต่างๆ ที่เกี่ยวข้องกับ Lisp, บน LispForum ^{[ 41 ]}ผู้ใช้พูดคุยเกี่ยวกับหัวข้อ Lisp, Lispjobs ^{[ 42 ]}เป็นบริการสำหรับการประกาศรับสมัครงาน และมีบริการข่าวรายสัปดาห์Weekly Lisp News Common-lisp.net เป็นเว็บไซต์โฮสติ้งสำหรับโครงการ Common Lisp โอเพนซอร์สQuicklisp ^{[ 43 ]}เป็นตัวจัดการไลบรารีสำหรับ Common Lisp

ครบรอบ 50 ปีของ Lisp (1958–2008) ได้รับการเฉลิมฉลองที่ LISP50@OOPSLA ^{[ 44 ]}มีการประชุมผู้ใช้ในท้องถิ่นเป็นประจำในบอสตัน แวนคูเวอร์ และฮัมบูร์ก กิจกรรมอื่นๆ ได้แก่ การประชุม European Common Lisp Meeting, European Lisp Symposium และการประชุม International Lisp Conference

ชุมชน Scheme ยังคงดูแลรักษาการใช้งานมากกว่า 20 รายการ อย่างต่อเนื่อง มีการพัฒนาการใช้งานใหม่ที่สำคัญหลายรายการ (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) ในช่วงทศวรรษ 2000 มาตรฐาน Scheme ฉบับแก้ไข รายงาน ⁵เกี่ยวกับภาษาอัลกอริธึม Scheme ^{[ 45 ]}ได้รับการยอมรับอย่างกว้างขวางในชุมชน Scheme กระบวนการ ร้องขอการใช้งาน Schemeได้สร้างไลบรารีและส่วนขยายกึ่งมาตรฐานจำนวนมากสำหรับ Scheme ชุมชนผู้ใช้ของการใช้งาน Scheme แต่ละรายการยังคงเติบโตอย่างต่อเนื่อง กระบวนการกำหนดมาตรฐานภาษาใหม่เริ่มต้นขึ้นในปี 2003 และนำไปสู่มาตรฐาน Scheme R6RS ^ในปี 2007 การใช้งาน Scheme ในเชิงวิชาการสำหรับการสอนวิทยาการคอมพิวเตอร์ดูเหมือนจะลดลงบ้าง มหาวิทยาลัยบางแห่งไม่ได้ใช้ Scheme ในหลักสูตรเบื้องต้นวิทยาการคอมพิวเตอร์อีกต่อไป^{[ 46 ] [ 47 ]}ปัจจุบัน MIT ใช้Pythonแทน Scheme สำหรับ หลักสูตร วิทยาศาสตรบัณฑิตสาขาคอมพิวเตอร์และหลักสูตรออนไลน์แบบเปิดขนาดใหญ่ MITx ^{[ 48 ] [ 49 ]}

มีภาษาถิ่นใหม่หลายภาษาของ Lisp ได้แก่Arc , Hy , Nu , Liskell และLFE (Lisp Flavored Erlang) ตัวแยกวิเคราะห์สำหรับJuliaนั้นถูกพัฒนาขึ้นด้วย Femtolisp ซึ่งเป็นภาษาถิ่นหนึ่งของScheme (Julia ได้รับแรงบันดาลใจจาก Scheme ซึ่งเป็นภาษาถิ่นหนึ่งของ Lisp อีกทีหนึ่ง)

ในเดือนตุลาคม 2019 พอล เกรแฮมได้เผยแพร่ข้อกำหนดสำหรับ Belซึ่งเป็น "ภาษาถิ่นใหม่ของ Lisp"

Lisp มีภาษาถิ่นมาตรฐานอย่างเป็นทางการ ได้แก่R6RS Scheme , R7RS Scheme , IEEE Scheme, ^{[ 59 ]} ANSI Common LispและISO ISLISP

ภาษา Lisp เป็นภาษาที่เน้นการใช้การแสดงออก (expression oriented language) แตกต่างจากภาษาอื่นๆ ส่วนใหญ่ Lisp ไม่แยกความแตกต่างระหว่าง "นิพจน์" และ"คำสั่ง"โค้ดและข้อมูลทั้งหมดเขียนในรูปของนิพจน์ เมื่อนิพจน์ถูกประเมินค่า จะได้ค่าหนึ่งค่า (อาจเป็นหลายค่า) ซึ่งสามารถนำไปใช้ในนิพจน์อื่นๆ ได้ แต่ละค่าสามารถเป็นชนิดข้อมูลใดก็ได้

บทความของ McCarthy ในปี 1958 ได้นำเสนอไวยากรณ์สองประเภท ได้แก่นิพจน์เชิงสัญลักษณ์ ( S-expressions , sexps) ซึ่งสะท้อนการแสดงผลภายในของโค้ดและข้อมูล และนิพจน์เมตา ( M-expressions ) ซึ่งแสดงฟังก์ชันของ S-expressions M-expressions ไม่ได้รับความนิยม และภาษา Lisp เกือบทั้งหมดในปัจจุบันใช้ S-expressions ในการจัดการทั้งโค้ดและข้อมูล

การใช้วงเล็บเป็นความแตกต่างที่เห็นได้ชัดที่สุดของ Lisp จากตระกูลภาษาโปรแกรมอื่นๆ ด้วยเหตุนี้ นักเรียนจึงมักตั้งฉายาให้ Lisp ว่าLost In Stupid ParenthesesหรือLots of Irritating Superfluous Parentheses [ ^{66 ] อย่างไรก็ตาม}ไวยากรณ์ S-expression ก็เป็นส่วนสำคัญที่ทำให้ Lisp มีประสิทธิภาพมากเช่นกัน ไวยากรณ์นั้นเรียบง่ายและสอดคล้องกัน ซึ่งช่วยให้คอมพิวเตอร์สามารถจัดการได้ง่าย อย่างไรก็ตาม ไวยากรณ์ของ Lisp ไม่ได้จำกัดอยู่แค่การใช้วงเล็บแบบดั้งเดิมเท่านั้น มันสามารถขยายให้รวมสัญกรณ์ทางเลือกอื่นๆ ได้ ตัวอย่างเช่น XMLisp เป็นส่วนขยายของ Common Lisp ที่ใช้โปรโตคอล metaobjectเพื่อรวม S-expression เข้ากับ Extensible Markup Language ( XML )

การพึ่งพาการใช้นิพจน์ทำให้ภาษามีความยืดหยุ่นสูง เนื่องจากฟังก์ชันของ Lisp เขียนในรูปแบบของลิสต์ จึงสามารถประมวลผลได้เหมือนกับข้อมูล ทำให้เขียนโปรแกรมที่ควบคุมโปรแกรมอื่นได้ง่าย ( เมตาโปรแกรมมิง ) ภาษา Lisp หลายภาษาใช้ประโยชน์จากคุณสมบัตินี้โดยใช้ระบบมาโคร ซึ่งช่วยให้สามารถขยายภาษาได้เกือบไร้ขีดจำกัด

ลิสต์ในภาษา Lisp เขียนโดยใช้ช่องว่าง คั่นระหว่างองค์ประกอบ และวงเล็บครอบไว้ ตัวอย่างเช่น ` list` คือลิสต์ที่มีองค์ประกอบเป็นอะตอม สามตัว ได้แก่ ` , , และ` ค่าเหล่านี้มีการกำหนดประเภทโดยปริยาย คือเป็นจำนวนเต็มสองตัวและชนิดข้อมูลเฉพาะของ Lisp ที่เรียกว่า "symbol" ตามลำดับ และไม่จำเป็นต้องประกาศเป็นชนิดข้อมูลดังกล่าว(12foo)12foo

รายการว่าง()เปล่ายังถูกแทนด้วยอะตอมพิเศษอีกด้วยnilนี่เป็นเอนทิตีเดียวในภาษาลิสป์ที่เป็นทั้งอะตอมและรายการในเวลาเดียวกัน

นิพจน์เขียนในรูปแบบรายการ โดยใช้สัญกรณ์แบบพรีฟิกองค์ประกอบแรกในรายการคือชื่อของฟังก์ชัน ชื่อของมาโคร นิพจน์แลมบ์ดา หรือชื่อของ "ตัวดำเนินการพิเศษ" (ดูด้านล่าง) ส่วนที่เหลือของรายการคืออาร์กิวเมนต์ ตัวอย่างเช่น ฟังก์ชันlistจะส่งคืนอาร์กิวเมนต์เป็นรายการ ดังนั้นนิพจน์จึงเป็นรายการ

( รายการ1 2 ( อ้างอิงfoo ))

ประเมินค่าเป็นลิสต์เครื่องหมาย "quote" ที่อยู่หน้าในตัวอย่างข้างต้น เป็น "ตัวดำเนินการพิเศษ" ซึ่งจะคืนค่าอาร์กิวเมนต์โดยไม่ต้องประเมินค่า นิพจน์ใดๆ ที่ไม่มีเครื่องหมาย quotee จะถูกประเมินค่าแบบเรียกซ้ำก่อนที่จะประเมินค่านิพจน์ที่อยู่ภายใน ตัวอย่างเช่น(12foo)foo

( รายการที่1 2 ( รายการที่3 4 ))

ประเมินค่าออกมาเป็นลิสต์อาร์กิวเมนต์ที่สามเป็นลิสต์ ซึ่งสามารถซ้อนกันได้(12(34))

ตัวดำเนินการทางคณิตศาสตร์ได้รับการปฏิบัติในลักษณะเดียวกัน นิพจน์

( + 1 2 3 4 )

มีค่าเท่ากับ 10 ค่าที่เทียบเท่าในรูปแบบการเขียนแบบอินฟิกซ์คือ " "1+2+3+4

ภาษา Lisp ไม่มีแนวคิดเรื่องตัวดำเนินการเหมือนใน ภาษาที่พัฒนามาจาก ALGOLตัวดำเนินการทางคณิตศาสตร์ใน Lisp เป็นฟังก์ชันแปรผัน (หรือn-ary ) ที่สามารถรับอาร์กิวเมนต์ได้หลายตัว ตัวดำเนินการเพิ่มค่าแบบ '++' ในแบบภาษา C บางครั้งก็ถูกนำมาใช้ภายใต้incfไวยากรณ์การตั้ง ชื่อ

( incf x )

เทียบเท่ากับ(setq x (+ x 1))การส่งคืนค่าใหม่xของ

"ตัวดำเนินการพิเศษ" (บางครั้งเรียกว่า "รูปแบบพิเศษ") เป็นโครงสร้างควบคุมของภาษา Lisp ตัวอย่างเช่น ตัวดำเนินการพิเศษifรับอาร์กิวเมนต์สามตัว ถ้าอาร์กิวเมนต์ตัวแรกไม่ใช่ค่าว่าง จะมีค่าเท่ากับอาร์กิวเมนต์ตัวที่สอง มิฉะนั้นจะมีค่าเท่ากับอาร์กิวเมนต์ตัวที่สาม ดังนั้นนิพจน์ `\n` จึงเป็นดังนี้

( ถ้าnil ( รายการ1 2 "foo" ) ( รายการ3 4 "bar" ))

ประเมินค่าได้เป็น. แน่นอนว่า วิธีนี้จะมีประโยชน์มากกว่าหากมีการแทนที่นิพจน์ที่ไม่ธรรมดาลงไปแทนที่.(34"bar")nil

นอกจากนี้ Lisp ยังมีตัวดำเนินการตรรกะand , orและnot ตัวดำเนินการ and และorจะทำการประเมินแบบลัดวงจร (short-circuit evaluation)และจะส่งคืนค่า nil และค่าที่ไม่ใช่ nil ตัวแรกตามลำดับ

( หรือ( และ"ศูนย์" nil "ไม่เคย" ) "เจมส์" 'งาน'เวลา)

จะประเมินผลเป็น "เจมส์"

ตัวดำเนินการพิเศษอีกตัวหนึ่งคือlambda`false` ใช้สำหรับผูกตัวแปรกับค่าต่างๆ ซึ่งจะถูกประเมินค่าภายในนิพจน์ ตัวดำเนินการนี้ยังใช้ในการสร้างฟังก์ชันด้วย โดยอาร์กิวเมนต์ของ `false` lambdaคือรายการของอาร์กิวเมนต์ และนิพจน์หรือนิพจน์ต่างๆ ที่ฟังก์ชันจะประเมินค่า (ค่าที่ส่งคืนคือค่าของนิพจน์สุดท้ายที่ถูกประเมิน) นิพจน์

( แลมบ์ดา( อาร์กิวเมนต์) ( + อาร์กิวเมนต์1 ))

นิพจน์แลมบ์ดา จะประเมินค่าเป็นฟังก์ชันที่เมื่อนำไปใช้จะรับอาร์กิวเมนต์หนึ่งตัว ผูกค่าอาร์กิวเมนต์นั้นเข้ากับargตัวแปร และส่งคืนค่าที่มากกว่าอาร์กิวเมนต์นั้นหนึ่งค่า นิพจน์แลมบ์ดาได้รับการปฏิบัติไม่แตกต่างจากฟังก์ชันที่มีชื่อ กล่าวคือเรียกใช้ในลักษณะเดียวกัน ดังนั้น นิพจน์

(( แลมบ์ดา( อาร์กิวเมนต์) ( + อาร์กิวเมนต์1 )) 5 )

ประเมินค่าได้เป็น6. ในที่นี้ เรากำลังทำการเรียกใช้ฟังก์ชัน: เราเรียกใช้ฟังก์ชันนิรนามโดยส่งค่า 5 เข้าไป

ฟังก์ชันที่มีชื่อจะถูกสร้างขึ้นโดยการจัดเก็บนิพจน์แลมบ์ดาไว้ในสัญลักษณ์โดยใช้มาโคร defun

( defun foo ( a b c d ) ( + a b c d ))

(defunf(a)b...)กำหนดฟังก์ชันใหม่ชื่อfในสภาพแวดล้อมส่วนกลาง โดยหลักการแล้วคล้ายกับนิพจน์:

( setf ( fdefinition 'f ) #' ( lambda ( a ) ( block f b... )))

โดยที่setfเป็นมาโครที่ใช้ในการกำหนดค่าของอาร์กิวเมนต์แรกให้กับอ็อบเจ็กต์ฟังก์ชันใหม่เป็นคำจำกัดความฟังก์ชันส่วนกลางสำหรับฟังก์ชันชื่อเป็นตัวย่อของตัวดำเนินการพิเศษ ซึ่งส่งคืนอ็อบเจ็กต์ฟังก์ชันfdefinition'ffdefinitionf#'function

ในภาษา LISP ดั้งเดิม มีชนิดข้อมูล พื้นฐานสองชนิด ได้แก่ อะตอมและลิสต์ ลิสต์เป็นลำดับขององค์ประกอบที่มีจำนวนจำกัด โดยแต่ละองค์ประกอบเป็นได้ทั้งอะตอมหรือลิสต์ และอะตอมอาจเป็นตัวเลขหรือสัญลักษณ์ สัญลักษณ์โดยพื้นฐานแล้วคือรายการที่มีชื่อเฉพาะ เขียนเป็น สตริง ตัวอักษรและตัวเลขในซอร์สโค้ดและใช้เป็นชื่อตัวแปรหรือเป็นรายการข้อมูลในการประมวลผลเชิงสัญลักษณ์ตัวอย่างเช่น ลิสต์ประกอบด้วยสามองค์ประกอบ ได้แก่ สัญลักษณ์, ลิสต์และตัวเลข 2(FOO(BAR1)2)FOO(BAR1)

รายการ Lisp ถูกนำไปใช้เป็นรายการเชื่อมโยงเดี่ยว^{[ 67 ]}แต่ละเซลล์ของรายการนี้เรียกว่าcons (ใน Scheme เรียกว่าpair ) และประกอบด้วยตัวชี้ สองตัว เรียกว่าcarและcdrซึ่งเทียบเท่ากับ ฟิลด์ dataและnextที่กล่าวถึงในบทความรายการเชื่อมโยง

ในบรรดาโครงสร้างข้อมูลมากมายที่สามารถสร้างขึ้นจากเซลล์ cons ได้ หนึ่งในโครงสร้างพื้นฐานที่สุดเรียกว่ารายการที่ถูกต้อง (proper list) รายการที่ถูกต้องอาจเป็นnilสัญลักษณ์พิเศษ (รายการว่าง) หรือ cons ที่carชี้ไปยังข้อมูล (ซึ่งอาจเป็นโครงสร้าง cons อื่น เช่น รายการ) และcdrชี้ไปยังรายการที่ถูกต้องอีกรายการหนึ่ง

ถ้าถือว่า cons ที่กำหนดเป็นหัวของลิสต์แบบเชื่อมโยงแล้ว car จะชี้ไปยังองค์ประกอบแรกของลิสต์ และ cdr จะชี้ไปยังส่วนที่เหลือของลิสต์ ด้วยเหตุนี้ ฟังก์ชัน `and` carและ ` or` cdrจึงถูกเรียกว่า `and` และ `or` firstเช่น กัน restเมื่ออ้างถึง cons ที่เป็นส่วนหนึ่งของลิสต์แบบเชื่อมโยง (แทนที่จะเป็นโครงสร้างแบบต้นไม้)

ดังนั้น รายการในภาษา Lisp จึงไม่ใช่วัตถุอะตอมิก เหมือนกับอินสแตนซ์ของคลาสคอนเทนเนอร์ใน C++ หรือ Java รายการเป็นเพียงการรวมกันของ cons ที่เชื่อมโยงกัน ตัวแปรที่อ้างถึงรายการที่กำหนดนั้นเป็นเพียงตัวชี้ไปยัง cons แรกในรายการ การท่องไปในรายการสามารถทำได้โดยการใช้คำสั่ง cdring ลงไปตามรายการ กล่าวคือ การใช้คำสั่ง cdring ต่อเนื่องกันเพื่อเยี่ยมชม cons แต่ละตัวในรายการ หรือโดยการใช้ฟังก์ชันลำดับสูง หลายฟังก์ชัน เพื่อแมปฟังก์ชันกับรายการ

เนื่องจาก conses และ lists เป็นโครงสร้างข้อมูลที่พบได้ทั่วไปในระบบ Lisp จึงมักเข้าใจผิดว่ามันเป็นโครงสร้างข้อมูลเพียงอย่างเดียวของ Lisp ที่จริงแล้ว Lisp เกือบทุกภาษา ยกเว้นภาษาที่เรียบง่ายที่สุด จะมีโครงสร้างข้อมูลอื่นๆ เช่น vectors ( arrays ), hash tables , structures และอื่นๆ อีกมากมาย

S-expression แทนรายการ

นิพจน์ S ที่อยู่ในวงเล็บแสดงถึงโครงสร้างรายการเชื่อมโยง มีหลายวิธีในการแสดงรายการเดียวกันในรูปแบบนิพจน์ S cons สามารถเขียนในรูปแบบสัญกรณ์จุดคู่ได้เป็น โดยที่คือรถยนต์ และคือ cdr รายการที่ถูกต้องยาวกว่าอาจเขียนในรูปแบบสัญกรณ์จุดคู่ โดยทั่วไปจะย่อเป็นในสัญกรณ์รายการ รายการ ที่ไม่เหมาะสม^{[หมายเหตุ 3 ]}อาจเขียนในรูปแบบผสมผสานระหว่างสองแบบ – เช่นรายการของ cons สามรายการที่มี cdr สุดท้ายคือ(นั่นคือ รายการในรูปแบบที่ระบุอย่างครบถ้วน)(a.b)ab(a.(b.(c.(d.nil))))(abcd)(abc.d)d(a.(b.(c.d)))

( รายการ1 2 'a 3 ) ;ผลลัพธ์: (1 2 a 3)

( รายการ1 ' ( 2 3 ) 4 ) ;ผลลัพธ์: (1 (2 3) 4)

( cons 1 ' ( 2 3 )) ;ผลลัพธ์: (1 2 3)

( cons ' ( 1 2 ) ' ( 3 4 )) ;ผลลัพธ์: ((1 2) 3 4)

( เพิ่ม' ( 1 2 ) ' ( 3 4 )) ;ผลลัพธ์: (1 2 3 4)

( เพิ่ม' ( 1 2 3 ) ' () ' ( a ) ' ( 5 6 )) ;ผลลัพธ์: (1 2 3 a 5 6)

( setf foo ( list 'a 'b 'c )) ( setf bar ( cons 'x ( cdr foo )))

( setf ( third foo ) 'goose )

ภาษา Lisp จะประเมินนิพจน์ที่ผู้ใช้ป้อนเข้ามา สัญลักษณ์และลิสต์จะประเมินค่าเป็นนิพจน์อื่น (โดยปกติแล้วจะง่ายกว่า) ตัวอย่างเช่น สัญลักษณ์จะประเมินค่าเป็นค่าของตัวแปรที่มันระบุชื่ออย่างไรก็ตามรูปแบบอื่นๆ ส่วนใหญ่จะประเมินค่าเป็นตัวมันเอง หากป้อนเข้าไปใน Lisp มันจะคืนค่าเป็น(+23)555

นอกจากนี้ ยังสามารถทำเครื่องหมายเพื่อป้องกันไม่ให้มีการประเมินค่าของนิพจน์ใดๆ (เช่นเดียวกับที่จำเป็นสำหรับสัญลักษณ์และลิสต์) นี่คือบทบาทของquoteตัวดำเนินการพิเศษ หรือตัวย่อของมัน'(เครื่องหมายอัญประกาศเดี่ยว) ตัวอย่างเช่น โดยปกติแล้ว หากป้อนสัญลักษณ์ `<int>` fooจะส่งคืนค่าของตัวแปรที่เกี่ยวข้อง (หรือข้อผิดพลาด หากไม่มีตัวแปรดังกล่าว) หากต้องการอ้างถึงสัญลักษณ์ตัวอักษร ให้ป้อน `<int>` หรือโดยปกติคือ ` <int> `(quotefoo)'foo

ทั้ง Common Lisp และ Scheme ยังรองรับ ตัวดำเนินการ backquote (เรียกว่าquasiquoteใน Scheme) ซึ่งป้อนด้วย`อักขระ ( Backtick ) ซึ่งเกือบจะเหมือนกับเครื่องหมายคำพูดธรรมดา ยกเว้นว่ามันอนุญาตให้ประเมินนิพจน์และแทรกค่าลงในรายการที่อยู่ในเครื่องหมายคำพูดด้วยตัวดำเนินการunquote ด้วยเครื่องหมายจุลภาค และตัว ดำเนิน การ splice ด้วย เครื่องหมายจุลภาค หากตัวแปรมีค่าเป็นก็จะประเมินค่าเป็นในขณะที่จะประเมินค่าเป็นเครื่องหมาย backquote มักใช้ในการกำหนดการขยายมาโคร^{[ 68 ] [ 69 ]},,@snue(barbaz)`(foo,snue)(foo(barbaz))`(foo,@snue)(foobarbaz)

ฟอร์มที่ประเมินค่าตัวเองได้และฟอร์มที่อยู่ในเครื่องหมายคำพูดนั้นเทียบเท่ากับค่าคงที่ในภาษา Lisp อาจเป็นไปได้ที่จะแก้ไขค่าของค่าคงที่ (ที่เปลี่ยนแปลงได้) ในโค้ดโปรแกรม ตัวอย่างเช่น หากฟังก์ชันส่งคืนฟอร์มที่อยู่ในเครื่องหมายคำพูด และโค้ดที่เรียกใช้ฟังก์ชันนั้นแก้ไขฟอร์มดังกล่าว อาจส่งผลต่อพฤติกรรมของฟังก์ชันในการเรียกใช้ครั้งต่อๆ ไป

( defun should-be-constant () ' ( one two three ))( let (( stuff ( should-be-constant ))) ( setf ( third stuff ) 'bizarre )) ; bad!( should-be-constant ) ; ส่งคืน (one two bizarre)

การแก้ไขรูปแบบที่อ้างอิงไว้แบบนี้โดยทั่วไปถือว่าเป็นรูปแบบที่ไม่ดี และมาตรฐาน ANSI Common Lisp ได้กำหนดไว้ว่าเป็นข้อผิดพลาด (ส่งผลให้เกิดพฤติกรรม "ไม่แน่นอน" ในไฟล์ที่คอมไพล์แล้ว เนื่องจากตัวคอมไพล์ไฟล์สามารถรวมค่าคงที่ที่คล้ายกันเข้าด้วยกัน ใส่ไว้ในหน่วยความจำที่ป้องกันการเขียน ฯลฯ)

การกำหนดรูปแบบการอ้างอิงอย่างเป็นทางการของภาษาลิสป์ได้รับการกล่าวถึงโดยดักลาส ฮอฟสตัดเตอร์ (ในGödel, Escher, Bach ) และคนอื่นๆ ว่าเป็นตัวอย่างของ แนวคิด ทางปรัชญาเรื่องการอ้างอิงตนเอง

ตระกูลภาษา Lisp มีความเห็นแตกต่างกันเกี่ยวกับการใช้ขอบเขตแบบไดนามิกหรือแบบคงที่ (หรือที่เรียกว่าขอบเขตเชิงคำศัพท์) Clojure, Common Lisp และ Scheme ใช้ขอบเขตแบบคงที่โดยค่าเริ่มต้น ในขณะที่newLISP , Picolispและภาษาที่ฝังอยู่ในEmacsและAutoCADใช้ขอบเขตแบบไดนามิก ตั้งแต่เวอร์ชัน 24.1 เป็นต้นมา Emacs ใช้ทั้งขอบเขตแบบไดนามิกและเชิงคำศัพท์

ความแตกต่างพื้นฐานระหว่าง Lisp กับภาษาโปรแกรมอื่นๆ คือ ใน Lisp การแสดงผลโปรแกรมในรูปแบบข้อความนั้นเป็นเพียงคำอธิบายที่มนุษย์อ่านได้ของโครงสร้างข้อมูลภายในเดียวกัน (รายการเชื่อมโยง สัญลักษณ์ ตัวเลข อักขระ ฯลฯ) กับที่ระบบ Lisp พื้นฐานใช้

ภาษา Lisp ใช้สิ่งนี้ในการสร้างระบบมาโครที่มีประสิทธิภาพสูงมาก เช่นเดียวกับภาษามาโครอื่นๆ เช่น ภาษามาโครที่กำหนดโดยพรีโปรเซสเซอร์ของภาษา C (พรีโปรเซสเซอร์มาโครสำหรับ ภาษาโปรแกรม C , Objective-CและC++ ) มาโครจะส่งคืนโค้ดที่สามารถคอมไพล์ได้ อย่างไรก็ตาม ต่างจากมาโครของพรีโปรเซสเซอร์ของภาษา C มาโครเหล่านี้เป็นฟังก์ชันของ Lisp ดังนั้นจึงสามารถใช้ประโยชน์จากพลังของ Lisp ได้อย่างเต็มที่

นอกจากนี้ เนื่องจากโค้ด Lisp มีโครงสร้างเหมือนกับลิสต์ จึงสามารถสร้างมาโครได้โดยใช้ฟังก์ชันประมวลผลลิสต์ใดๆ ในภาษา กล่าวโดยสรุปคือ สิ่งใดก็ตามที่ Lisp สามารถทำกับโครงสร้างข้อมูลได้ มาโครของ Lisp ก็สามารถทำกับโค้ดได้เช่นกัน ในทางตรงกันข้าม ในภาษาอื่นๆ ส่วนใหญ่ ผลลัพธ์ของตัวแยกวิเคราะห์จะเป็นเพียงส่วนภายในของการใช้งานภาษา และโปรแกรมเมอร์ไม่สามารถจัดการได้

คุณสมบัตินี้ทำให้การพัฒนา ภาษา ที่มีประสิทธิภาพภายในภาษาอื่นทำได้ง่าย ตัวอย่างเช่น ระบบออบเจ็กต์ของ Common Lisp สามารถนำมาใช้เป็นส่วนขยายของภาษาได้อย่างเรียบร้อยโดยใช้มาโคร ซึ่งหมายความว่าหากแอปพลิเคชันต้องการกลไกการสืบทอดที่แตกต่างกัน ก็สามารถใช้ระบบออบเจ็กต์อื่นได้ นี่เป็นสิ่งที่แตกต่างอย่างสิ้นเชิงกับภาษาอื่นๆ ส่วนใหญ่ ตัวอย่างเช่น Java ไม่รองรับการสืบทอดแบบหลายทาง และไม่มีวิธีที่เหมาะสมในการเพิ่มการสืบทอดดังกล่าว

ในการใช้งาน Lisp แบบง่ายๆ โครงสร้างลิสต์นี้จะถูกตีความ โดยตรง เพื่อรันโปรแกรม ฟังก์ชันก็คือส่วนหนึ่งของโครงสร้างลิสต์ที่ตัวตีความจะวนลูปผ่านในระหว่างการประมวลผล อย่างไรก็ตาม ระบบ Lisp ที่ซับซ้อนส่วนใหญ่จะมีคอมไพเลอร์ด้วย คอมไพเลอร์จะแปลงโครงสร้างลิสต์เป็นรหัสเครื่องหรือไบต์โค้ดเพื่อการประมวลผล รหัสนี้สามารถทำงานได้เร็วเท่ากับรหัสที่คอมไพล์ในภาษาทั่วไป เช่น C

มาโครจะขยายก่อนขั้นตอนการคอมไพล์ และด้วยเหตุนี้จึงมีตัวเลือกที่น่าสนใจบางอย่าง หากโปรแกรมต้องการตารางที่คำนวณไว้ล่วงหน้า มาโครอาจสร้างตารางในระหว่างการคอมไพล์ ดังนั้นคอมไพเลอร์จึงต้องแสดงผลตารางออกมาเท่านั้น และไม่จำเป็นต้องเรียกโค้ดเพื่อสร้างตารางในระหว่างการทำงาน การใช้งาน Lisp บางอย่างยังมีกลไกeval-whenที่อนุญาตให้โค้ดมีอยู่ในระหว่างการคอมไพล์ (เมื่อมาโครต้องการ) แต่ไม่มีอยู่ในโมดูลที่ส่งออกมา^{[ 70 ]}

ภาษา Lisp มักใช้ร่วมกับบรรทัดคำสั่งแบบ โต้ตอบ ซึ่งอาจรวมกับสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) ผู้ใช้พิมพ์นิพจน์ที่บรรทัดคำสั่ง หรือสั่งให้ IDE ส่งนิพจน์เหล่านั้นไปยังระบบ Lisp ภาษา Lisp จะอ่านนิพจน์ที่ป้อนเข้ามาประเมินผล และพิมพ์ผลลัพธ์ ด้วยเหตุนี้ บรรทัดคำสั่งของ Lisp จึงเรียกว่าวงจรการอ่าน-ประเมิน-พิมพ์ ( REPL )

การทำงานพื้นฐานของ REPL มีดังนี้ นี่เป็นคำอธิบายอย่างง่ายที่ละเว้นองค์ประกอบหลายอย่างของภาษา Lisp จริงๆ เช่น การอ้างอิงข้อความและการใช้มาโคร

ฟังก์ชัน นี้readรับนิพจน์ S ที่เป็นข้อความเป็นอินพุต และแยกวิเคราะห์นิพจน์เหล่านั้นเป็นโครงสร้างข้อมูลภายใน ตัวอย่างเช่น หากคุณพิมพ์ข้อความที่พรอมต์ ฟังก์ชันจะแปลงข้อความนั้นเป็นรายการเชื่อมโยงที่มีสามองค์ประกอบ ได้แก่ สัญลักษณ์, ตัวเลข 1 และตัวเลข 2 บังเอิญว่ารายการนี้ก็เป็นโค้ด Lisp ที่ถูกต้องเช่นกัน กล่าวคือ สามารถประเมินค่าได้ เนื่องจากองค์ประกอบหลักของรายการระบุชื่อฟังก์ชัน ซึ่งก็คือการดำเนินการบวก(+12)read+

ตัว อักษร A fooจะถูกอ่านเป็นสัญลักษณ์เดี่ยว ตัวอักษร123จะถูกอ่านเป็นตัวเลขหนึ่งร้อยยี่สิบสาม"123"ตัวอักษร จะถูกอ่านเป็นสตริง "123"

ฟังก์ชัน นี้evalจะประเมินข้อมูลและส่งคืนข้อมูล Lisp อื่นๆ ตั้งแต่ศูนย์รายการขึ้นไปเป็นผลลัพธ์ การประเมินไม่จำเป็นต้องหมายถึงการตีความเสมอไป ระบบ Lisp บางระบบจะคอมไพล์ทุกนิพจน์เป็นรหัสเครื่องดั้งเดิม อย่างไรก็ตาม การอธิบายการประเมินในแง่ของการตีความนั้นทำได้ง่าย: ในการประเมินรายการที่มีชื่อฟังก์ชันอยู่evalในตัวแปรย่อย ขั้นแรกจะประเมินอาร์กิวเมนต์แต่ละตัวที่ระบุในตัวแปรย่อย จากนั้นจึงใช้ฟังก์ชันกับอาร์กิวเมนต์เหล่านั้น ในกรณีนี้ ฟังก์ชันคือการบวก และการนำไปใช้กับรายการอาร์กิวเมนต์จะให้คำตอบซึ่งเป็นผลลัพธ์ของการประเมิน(12)3

สัญลักษณ์นี้fooจะประเมินค่าเป็นค่าของสัญลักษณ์ foo ข้อมูลเช่นสตริง "123" จะประเมินค่าเป็นสตริงเดียวกัน รายการจะประเมินค่าเป็นรายการ (1 2 3)(quote(123))

หน้าที่ของprintฟังก์ชันคือการแสดงผลลัพธ์ให้ผู้ใช้เห็น สำหรับผลลัพธ์ที่เรียบง่ายเช่น3นี้ถือว่าง่ายมาก แต่ถ้าเป็นนิพจน์ที่ประเมินค่าเป็นโครงสร้างรายการ จะต้องวนprintลูปผ่านรายการนั้นและพิมพ์ออกมาเป็นนิพจน์ S

ในการสร้าง REPL ด้วยภาษา Lisp นั้น จำเป็นต้องเขียนฟังก์ชันเพียงสามฟังก์ชันนี้และฟังก์ชันวนลูปไม่สิ้นสุด (แน่นอนว่า การเขียนฟังก์ชันนี้evalจะซับซ้อนกว่า เพราะต้องเขียนตัวดำเนินการพิเศษทั้งหมด เช่นifหรือ ด้วยlambda) เมื่อทำเช่นนี้แล้ว REPL พื้นฐานก็จะมีโค้ดเพียงบรรทัดเดียว:(loop(print(eval(read))))

โดยทั่วไปแล้ว Lisp REPL ยังมีฟังก์ชันการแก้ไขข้อมูลป้อนเข้า ประวัติข้อมูลป้อนเข้า การจัดการข้อผิดพลาด และอินเทอร์เฟซสำหรับดีบักเกอร์ด้วย

โดยปกติแล้ว Lisp จะถูกประเมินผลอย่างรวดเร็วในCommon Lispอาร์กิวเมนต์จะถูกประเมินตามลำดับการประยุกต์ใช้ ('ซ้ายสุดภายในสุด') ในขณะที่ในSchemeลำดับของอาร์กิวเมนต์นั้นไม่แน่นอน ทำให้มีช่องว่างสำหรับการปรับแต่งโดยคอมไพเลอร์

เดิมทีภาษา Lisp มีโครงสร้างควบคุมเพียงไม่กี่อย่าง แต่มีการเพิ่มโครงสร้างควบคุมอีกมากมายในระหว่างการพัฒนาของภาษา (ตัวดำเนินการเงื่อนไขดั้งเดิมของ Lisp condคือ เป็นต้นแบบของif-then-elseโครงสร้างควบคุมในภายหลัง)

โปรแกรมเมอร์ในภาษา Scheme มักจะแสดงลูปโดยใช้การเรียกซ้ำแบบหาง (tail recursion ) ความแพร่หลายของ Scheme ในวิทยาศาสตร์คอมพิวเตอร์เชิงวิชาการทำให้บางคนเชื่อว่าการเรียกซ้ำแบบหางเป็นวิธีเดียวหรือเป็นวิธีที่พบมากที่สุดในการเขียนการวนซ้ำใน Lisp แต่สิ่งนี้ไม่ถูกต้อง ภาษา Lisp ที่พบเห็นบ่อยทั้งหมดมีโครงสร้างการวนซ้ำแบบเชิงคำสั่ง ตั้งแต่doลูปของ Scheme ไปจนถึง นิพจน์ ที่ซับซ้อนของCommon Lisploopยิ่งไปกว่านั้น ประเด็นสำคัญที่ทำให้เรื่องนี้เป็นเรื่องที่เป็นกลางมากกว่าเรื่องส่วนตัวคือ Scheme กำหนดข้อกำหนดเฉพาะสำหรับการจัดการการเรียกแบบหางและด้วยเหตุนี้เหตุผลที่การใช้การเรียกซ้ำแบบหางได้รับการสนับสนุนโดยทั่วไปใน Scheme จึงเป็นเพราะการปฏิบัตินี้ได้รับการสนับสนุนอย่างชัดเจนโดยคำจำกัดความของภาษา ในทางตรงกันข้าม ANSI Common Lisp ไม่ต้องการ^{[ 71 ]}การเพิ่มประสิทธิภาพที่เรียกกันทั่วไปว่าการกำจัดการเรียกแบบหาง ดังนั้น ข้อเท็จจริงที่ว่ารูปแบบการเรียกซ้ำแบบหางเป็นการทดแทนแบบไม่เป็นทางการสำหรับการใช้ โครงสร้าง การวนซ้ำแบบ ดั้งเดิมมากขึ้น (เช่นdoหรือ) ไม่เป็นที่นิยม^{[ 72 ]}ใน Common Lisp ไม่ใช่แค่เรื่องของความชอบทางสไตล์เท่านั้น แต่ยังอาจเป็นเรื่องของประสิทธิภาพ (เนื่องจากการเรียกแบบหางที่เห็นได้ชัดใน Common Lisp อาจไม่สามารถคอมไพล์เป็นการกระโดดแบบง่ายๆ ได้dolist) และความถูกต้องของโปรแกรม (เนื่องจากการเรียกซ้ำแบบหางอาจเพิ่มการใช้สแต็กใน Common Lisp ซึ่งเสี่ยงต่อการเกิดสแต็กโอเวอร์โฟลว์ )loop

โครงสร้างควบคุมบางอย่างในภาษา Lisp เป็นตัวดำเนินการพิเศษซึ่งเทียบเท่ากับคำหลักทางไวยากรณ์ในภาษาอื่นๆ นิพจน์ที่ใช้ตัวดำเนินการเหล่านี้มีลักษณะภายนอกเหมือนกับการเรียกใช้ฟังก์ชัน แต่แตกต่างตรงที่อาร์กิวเมนต์ไม่จำเป็นต้องได้รับการประเมินค่า หรือในกรณีของนิพจน์การวนซ้ำ อาจถูกประเมินค่ามากกว่าหนึ่งครั้ง

แตกต่างจากภาษาโปรแกรมหลักอื่นๆ ส่วนใหญ่ ภาษา Lisp อนุญาตให้ใช้ภาษาในการสร้างโครงสร้างควบคุมได้ โครงสร้างควบคุมหลายอย่างถูกสร้างขึ้นในรูปแบบของมาโครในภาษา Lisp และโปรแกรมเมอร์ที่ต้องการทราบวิธีการทำงานของมันยังสามารถขยายมาโครเหล่านั้นได้อีกด้วย

ทั้ง Common Lisp และ Scheme ต่างก็มีตัวดำเนินการสำหรับควบคุมการไหลของโปรแกรมที่ไม่ใช่แบบโลคอล ความแตกต่างในตัวดำเนินการเหล่านี้เป็นความแตกต่างที่สำคัญที่สุดอย่างหนึ่งระหว่างสองภาษา Scheme รองรับ การทำงาน ต่อเนื่องแบบเรียกซ้ำได้โดยใช้call/ccขั้นตอน ซึ่งช่วยให้โปรแกรมสามารถบันทึก (และเรียกคืนในภายหลัง) ตำแหน่งเฉพาะในการทำงานได้ Common Lisp ไม่รองรับการทำงานต่อเนื่องแบบเรียกซ้ำได้ แต่รองรับวิธีการจัดการการทำงานต่อเนื่องแบบหลีกเลี่ยงได้หลายวิธี

บ่อยครั้งที่อัลกอริทึมเดียวกันสามารถแสดงในภาษา Lisp ได้ทั้งในรูปแบบคำสั่งหรือรูปแบบฟังก์ชัน ดังที่กล่าวไว้ข้างต้น ภาษา Scheme มักจะนิยมรูปแบบฟังก์ชัน โดยใช้การเรียกซ้ำแบบหาง (tail recursion) และ continuations เพื่อแสดงการควบคุมการไหลของโปรแกรม อย่างไรก็ตาม รูปแบบคำสั่งก็ยังเป็นไปได้เช่นกัน รูปแบบที่โปรแกรมเมอร์ Common Lisp หลายคนนิยมใช้อาจดูคุ้นเคยมากกว่าสำหรับโปรแกรมเมอร์ที่คุ้นเคยกับภาษาที่มีโครงสร้าง เช่น C ในขณะที่รูปแบบที่โปรแกรมเมอร์ Scheme นิยมใช้จะคล้ายกับภาษาฟังก์ชันบริสุทธิ์ เช่นHaskell มากกว่า

เนื่องจาก Lisp มีรากฐานมาจากการประมวลผลรายการ จึงมีฟังก์ชันลำดับสูงมากมายที่เกี่ยวข้องกับการวนซ้ำตามลำดับ ในหลายกรณีที่ภาษาอื่น ๆ จำเป็นต้องใช้ลูปแบบชัดเจน (เช่นforลูปในภาษา C) ใน Lisp สามารถทำงานเดียวกันได้ด้วยฟังก์ชันลำดับสูง (เช่นเดียวกับภาษาการเขียนโปรแกรมเชิงฟังก์ชันหลายภาษา)

ตัวอย่างที่ดีคือฟังก์ชันที่ใน Scheme เรียกว่า `initialize` mapและใน Common Lisp เรียกว่า `initialize` mapcarโดยกำหนดฟังก์ชันและลิสต์ตั้งแต่หนึ่งลิสต์ขึ้นไป ฟังก์ชันนี้mapcarจะนำฟังก์ชันไปใช้กับองค์ประกอบของลิสต์เหล่านั้นตามลำดับ และรวบรวมผลลัพธ์ไว้ในลิสต์ใหม่:

( mapcar #' + ' ( 1 2 3 4 5 ) ' ( 10 20 30 40 50 ))

ฟังก์ชัน นี้จะถูกนำไปใช้+กับองค์ประกอบแต่ละคู่ในรายการที่สอดคล้องกัน ซึ่งจะให้ผลลัพธ์ดังนี้(1122334455)