Lisp (ภาษาโปรแกรม)

จากวิกิพีเดีย สารานุกรมเสรี
ข้ามไปที่การนำทาง ข้ามไปที่การค้นหา
Lisp
Lisp logo.svg
กระบวนทัศน์หลายกระบวนทัศน์ : การทำงาน , ขั้นตอน , ไตร่ตรอง , meta
ออกแบบโดยJohn McCarthy
นักพัฒนาสตีฟ รัสเซลล์ , ทิโมธี พี. ฮาร์ต และ ไมค์ เลวิน
ปรากฏตัวครั้งแรก2501 ; 64 ปีที่แล้ว ( 2501 )
วินัยการพิมพ์ไดนามิกแข็งแกร่ง _
ภาษาถิ่น
ได้รับอิทธิพลจาก
IPL
ได้รับอิทธิพล

Lisp (หรือ LISPในอดีต) คือกลุ่มภาษาโปรแกรมที่มีประวัติยาวนานและมีสัญลักษณ์นำหน้าที่ มี วงเล็บ ครบถ้วน [3] ระบุครั้งแรกในปี 1958 Lisp เป็นภาษาการเขียนโปรแกรมระดับสูงที่ เก่าแก่เป็นอันดับ สอง มีเพียงFortran เท่านั้น ที่แก่กว่าหนึ่งปี [4] [5] Lisp เปลี่ยนไปตั้งแต่เริ่มแรกและมีภาษาถิ่น มากมาย ในประวัติศาสตร์ ทุกวันนี้ ภาษาถิ่น Lisp ที่ใช้กันทั่วไปที่รู้จักกันดีที่สุดคือRacket , Common Lisp , SchemeและClojure [ต้องการการอ้างอิง ]

เสียงกระเพื่อมถูกสร้างขึ้นเป็นสัญกรณ์คณิตศาสตร์เชิง ปฏิบัติ สำหรับโปรแกรมคอมพิวเตอร์ได้รับอิทธิพลจาก (แต่ไม่ได้มาจากเดิม) [6]สัญกรณ์ของแคลคูลัสแลมบ์ดาของโบสถ์อลอนโซ มันกลายเป็นภาษาการเขียนโปรแกรมที่โปรดปรานสำหรับ การวิจัย ปัญญาประดิษฐ์ (AI) อย่างรวดเร็ว [7]ในฐานะที่เป็นหนึ่งในภาษาการเขียนโปรแกรมที่เก่าแก่ที่สุด Lisp ได้บุกเบิกแนวคิดมากมายในด้านวิทยาการคอมพิวเตอร์รวมถึงโครงสร้างข้อมูลแบบต้นไม้การจัดการที่เก็บข้อมูลอัตโนมัติ การพิมพ์แบบไดนามิกเงื่อนไข ฟังก์ชันลำดับ ที่สูงกว่าการเรียกซ้ำ คอมไพเลอ ร์แบบโฮสต์เอง[8]และ ลู read–eval–print [9]

ชื่อLISPมาจาก "LISt Processor" [10] รายการที่เชื่อมโยงเป็นหนึ่งในโครงสร้างข้อมูล หลักของ Lisp และซอร์สโค้ด Lisp นั้นสร้างจากรายการ ดังนั้นโปรแกรม Lisp สามารถจัดการซอร์สโค้ดเป็นโครงสร้างข้อมูล ทำให้เกิด ระบบ มาโครที่อนุญาตให้โปรแกรมเมอร์สร้างไวยากรณ์ใหม่หรือภาษาเฉพาะโดเมน ใหม่ที่ ฝังอยู่ใน Lisp

ความสามารถในการใช้แทนกันได้ของโค้ดและข้อมูลทำให้ Lisp มีรูปแบบที่จดจำได้ในทันที รหัสโปรแกรมทั้งหมดเขียนเป็นs-expressionsหรือรายการในวงเล็บ การเรียกฟังก์ชันหรือรูปแบบวากยสัมพันธ์ถูกเขียนเป็นรายการที่มีชื่อฟังก์ชันหรือตัวดำเนินการก่อน และอาร์กิวเมนต์ต่อไปนี้ ตัวอย่างเช่น ฟังก์ชันfที่รับสามอาร์กิวเมนต์จะถูกเรียกว่าเป็น. (f arg1 arg2 arg3)

ประวัติ

John McCarthy (บนสุด) และSteve Russell

John McCarthyพัฒนา Lisp ในปี 1958 ขณะที่เขาอยู่ที่สถาบันเทคโนโลยีแมสซาชูเซตส์ (MIT) McCarthy ตีพิมพ์การออกแบบในบทความเรื่องCommunications of the ACMในปี 1960 เรื่อง "Recursive Functions of Symbolic Expressions and their Computation by Machine, Part I" [11]เขาแสดงให้เห็นว่าด้วยโอเปอเรเตอร์ง่ายๆ สองสามตัวและเครื่องหมายสำหรับฟังก์ชันนิรนามที่ยืมมาจากคริสตจักร เราสามารถสร้าง ภาษา ทัวริงที่สมบูรณ์สำหรับอัลกอริธึมได้

ภาษาการประมวลผลข้อมูลเป็น ภาษา AIภาษาแรกตั้งแต่ปีพ.

สัญกรณ์ดั้งเดิมของ McCarthy ใช้ " นิพจน์ M " ในวงเล็บ ซึ่งจะแปลเป็นS -expressions ตัวอย่างเช่น นิพจน์ M car[cons[A,B]]เทียบเท่ากับนิพจน์S เมื่อใช้งาน Lisp แล้ว โปรแกรมเมอร์ก็เลือกใช้ S-expressions อย่างรวดเร็ว และ M-expression ถูกยกเลิก M-นิพจน์ปรากฏขึ้นอีกครั้งด้วยความพยายามในระยะเวลาสั้นของMLisp [12]โดย Horace EneaและCGOLโดยVaughan Pratt(car (cons A B))

Lisp ถูกนำมาใช้ครั้งแรกโดยSteve Russellบน คอมพิวเตอร์ IBM 704โดยใช้การ์ดเจาะรู [13]รัสเซลได้อ่านเอกสารของแม็กคาร์ธีและตระหนักว่า (ทำให้แม็กคาร์ธีแปลกใจ) ว่าฟังก์ชัน Lisp evalสามารถนำมาใช้ในรหัสเครื่องได้

ตามที่แมคคาร์ธี: [14]

"สตีฟ รัสเซลล์พูด ฟังนะ ทำไมฉันไม่เขียนโปรแกรมeval นี้ซะ  ... และฉันบอกเขาว่า โฮ โฮ คุณกำลังสับสนระหว่างทฤษฎีกับการฝึกฝนevalนี้มีไว้เพื่อการอ่าน ไม่ใช่เพื่อการคำนวณ แต่เขาไป ไปข้างหน้าและทำมัน นั่นคือเขารวบรวมevalในกระดาษของฉันเป็นรหัสเครื่องIBM 704 แก้ไข ข้อผิดพลาดแล้วโฆษณาสิ่งนี้เป็น Lisp interpreter ซึ่งมันเป็นอย่างแน่นอน ดังนั้น ณ จุดนั้น Lisp จึงมีรูปแบบเป็นหลักที่มี วันนี้ ..."

ผลลัพธ์ที่ได้คือล่าม Lisp ที่ใช้งานได้ซึ่งสามารถใช้เพื่อรันโปรแกรม Lisp หรือ "ประเมินนิพจน์ Lisp" ได้อย่างเหมาะสมยิ่งขึ้น

มาโครภาษาแอสเซมบลีสองตัวสำหรับIBM 704กลายเป็นการดำเนินการดั้งเดิมสำหรับรายการแยกย่อย: car( เนื้อหาของส่วนที่อยู่ของหมายเลข Register) และcdr( เนื้อหาของส่วน Decrement ของหมายเลข Register) [15]โดยที่ "register" หมายถึงการลงทะเบียนของหน่วยประมวลผลกลาง (CPU) ของคอมพิวเตอร์ ภาษาถิ่นยังคงใช้carและcdr( / k ɑːr /และ/ ˈ k ʊ d ər /) สำหรับการดำเนินการที่ส่งคืนรายการแรกในรายการและส่วนที่เหลือของรายการตามลำดับ

คอมไพเลอร์ Lisp แบบสมบูรณ์ตัวแรกที่เขียนด้วยภาษา Lisp ถูกใช้งานในปี 1962 โดย Tim Hart และ Mike Levin ที่ MIT และสามารถคอมไพล์ได้โดยเพียงแค่ให้ล่าม LISP ที่มีอยู่แปลโค้ดของคอมไพเลอร์ ทำให้ เอาต์พุต โค้ดเครื่องสามารถดำเนินการได้ที่ ความเร็วที่เพิ่มขึ้นกว่าล่ามถึง 40 เท่า [16]คอมไพเลอร์นี้แนะนำโมเดล Lisp ของการคอมไพล์แบบเพิ่ม หน่วย ซึ่งฟังก์ชันที่คอมไพล์และตีความสามารถผสมผสานได้อย่างอิสระ ภาษาที่ใช้ในบันทึกของ Hart และ Levin นั้นใกล้เคียงกับสไตล์ Lisp สมัยใหม่มากกว่าโค้ดก่อนหน้าของ McCarthy

กิจวัตรการ เก็บขยะได้รับการพัฒนาโดยนักศึกษาระดับบัณฑิตศึกษาของ MIT [ ต้องการอ้างอิง ] Daniel Edwardsก่อนปี 1962 [17]

ในช่วงปี 1980 และ 1990 มีความพยายามอย่างมากในการรวมงานในภาษา Lisp ใหม่ (ส่วนใหญ่สืบทอดมาจากMaclispเช่นZetaLispและ NIL (New Implementation of Lisp) เป็นภาษาเดียว ภาษาใหม่Common Lispค่อนข้างเข้ากันได้ ด้วยภาษาถิ่นมันถูกแทนที่ (หนังสือCommon Lisp the Languageบันทึกความเข้ากันได้ของโครงสร้างต่างๆ) ในปี 1994 ANSIได้เผยแพร่มาตรฐาน Common Lisp "ANSI X3.226-1994 Information Technology Programming Language Common Lisp"

ไทม์ไลน์

พ.ศ. 2498 1960 พ.ศ. 2508 1970 พ.ศ. 2518 1980 พ.ศ. 2528 1990 1995 2000 2005 2010 2015 2020
 LISP 1, 1.5, LISP 2 (ละทิ้ง)
 Maclisp
 Interlisp
 MDL (ภาษาโปรแกรม)
 เครื่อง Lisp Lisp
 โครงการ  R5RS  R6RS  R7RS เล็ก
 นิล
 ZIL (ภาษาการใช้งาน Zork)
 Franz Lisp
 สามัญ Lisp
 Le Lisp
 ตู่
 Chez Scheme
 Emacs Lisp
 AutoLISP
 PicoLisp
 EuLisp
 ISLISP
 OpenLisp
 โครงการ PLT  แร็กเกต
 GNU Guile
 Visual LISP
 Clojure
 อาร์ค
 LFE
 ฮ่วย

การเชื่อมต่อกับปัญญาประดิษฐ์

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

ลำดับวงศ์ตระกูลและตัวแปร

ตลอดหกสิบปีของประวัติศาสตร์ Lisp ได้สร้างรูปแบบต่างๆ มากมายในธีมหลักของภาษา S-expression นอกจากนี้ ภาษาถิ่นที่ให้มาแต่ละภาษาอาจมีการใช้งานหลายอย่าง—ตัวอย่างเช่น มีการใช้งาน Common Lispมากกว่าหนึ่งโหล

ความแตกต่างระหว่างภาษาถิ่นอาจมองเห็นได้ค่อนข้างชัดเจน ตัวอย่างเช่น Common Lisp ใช้คำหลักdefunเพื่อตั้งชื่อฟังก์ชัน แต่ Scheme ใช้define. [19]ภายในภาษาถิ่นที่เป็นมาตรฐาน อย่างไรก็ตาม การใช้งานที่สอดคล้องกันสนับสนุนภาษาหลักเดียวกัน แต่มีส่วนขยายและไลบรารีต่างกัน

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

เครื่องLispในพิพิธภัณฑ์ MIT
  • LISP 1 (20) – การใช้งานครั้งแรก
  • LISP 1.5 [21] – เวอร์ชันแรกที่เผยแพร่อย่างกว้างขวาง พัฒนาโดย McCarthy และคนอื่นๆ ที่ MIT ตั้งชื่อนี้เพราะมีการปรับปรุงหลายอย่างในล่าม "LISP 1" ดั้งเดิม แต่ไม่ใช่การปรับโครงสร้างครั้งใหญ่อย่างที่LISP 2 วางแผน ไว้
  • Stanford LISP 1.6 [22] – นี่คือการสืบทอดต่อจาก LISP 1.5 ที่พัฒนาขึ้นที่Stanford AI Labและกระจายอย่างกว้างขวางไปยัง ระบบ PDP-10ที่ใช้ระบบปฏิบัติการTOPS -10 Maclisp และ InterLisp เลิกใช้แล้ว
  • MACLISP [23] – พัฒนาขึ้นสำหรับProject MAC ของ MIT โดย MACLISP เป็นทายาทสายตรงของ LISP 1.5 มันทำงานบน ระบบPDP-10 และMultics ต่อมา MACLISP จะถูกเรียกว่า Maclisp และมักถูกเรียกว่า MacLisp "MAC" ใน MACLISP ไม่เกี่ยวข้องกับMacintoshของ Apple หรือMcCarthy
  • Interlisp [24] – พัฒนาขึ้นที่BBN Technologiesสำหรับระบบ PDP-10 ที่ใช้ระบบปฏิบัติการ TENEXภายหลังนำมาใช้เป็น Lisp "ฝั่งตะวันตก" สำหรับเครื่อง Xerox Lisp เป็นInterLisp -D รุ่นเล็กที่เรียกว่า "InterLISP 65" ได้รับการเผยแพร่สำหรับสายคอมพิวเตอร์ตระกูล Atari 8 บิต ที่ใช้ 6502 Maclisp และ InterLisp เป็นคู่แข่งที่แข็งแกร่งมาระยะหนึ่งแล้ว
  • Franz Lisp – เดิมเป็นโครงการUniversity of California, Berkeley ; ภายหลังพัฒนาโดย Franz Inc. ชื่อนี้เป็นชื่อที่เสียรูปอย่างตลกขบขันของชื่อ " Franz Liszt " และไม่ได้หมายถึงAllegro Common Lispซึ่งเป็นภาษาถิ่นของ Common Lisp ที่ขายโดย Franz Inc. ในช่วงไม่กี่ปีที่ผ่านมา
  • XLISPซึ่งAutoLISPยึดตาม
  • Standard LispและPortable Standard Lispถูกนำมาใช้กันอย่างแพร่หลายและถูกย้าย โดยเฉพาะอย่างยิ่งกับ Computer Algebra System REDUCE
  • ZetaLispหรือที่เรียกว่า Lisp Machine Lisp - ใช้กับเครื่อง Lispซึ่งเป็นทายาทสายตรงของ Maclisp ZetaLisp มีอิทธิพลอย่างมากต่อ Common Lisp
  • LeLispเป็นภาษาถิ่นภาษาฝรั่งเศส หนึ่งในตัวสร้างส่วน ต่อประสานแรก (เรียกว่า SOS Interface [25] ) ถูกเขียนใน LeLisp
  • โครงการ (1975). (26)
  • Common Lisp (1984) ตามที่อธิบายโดยCommon Lisp the Language – การรวมความพยายามที่แตกต่างกันหลายครั้ง (ZetaLisp, Spice Lisp , NILและS-1 Lisp ) เพื่อสร้างภาษาถิ่นที่สืบทอดต่อ[27]ถึง Maclisp โดยได้รับอิทธิพลอย่างมากจากโครงการ ภาษาถิ่นเช่นกัน Common Lisp เวอร์ชันนี้มีให้สำหรับแพลตฟอร์มที่หลากหลายและได้รับการยอมรับจากหลายๆ คนว่าเป็นมาตรฐานโดยพฤตินัย[28]จนกระทั่งมีการเผยแพร่ 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 [29]และต่อมาแก้ไขเป็น ISO/IEC 13816:2007: [30] เทคโนโลยีสารสนเทศ – ภาษาการเขียนโปรแกรม สภาพแวดล้อม และอินเทอร์เฟซซอฟต์แวร์ระบบ – ภาษาการเขียนโปรแกรม ISLISP
  • โครงการ IEEE – มาตรฐาน IEEE, 1178–1990 (R1995)
  • ANSI Common LispมาตรฐานAmerican National Standards Institute (ANSI) สำหรับ Common Lisp ที่สร้างขึ้นโดยคณะอนุกรรมการX3J13ได้ว่าจ้าง[31]เพื่อเริ่มต้นด้วยCommon Lisp: The Languageเป็นเอกสารพื้นฐานและทำงานผ่าน กระบวนการ ฉันทามติ สาธารณะ เพื่อหาแนวทางแก้ไข ปัญหาการพกพาของโปรแกรมและความเข้ากันได้ของการใช้งาน Common Lisp ที่ใช้ร่วมกัน แม้ว่าจะเป็นมาตรฐาน ANSI อย่างเป็นทางการ แต่การนำไปใช้ การขาย การใช้ และอิทธิพลของ ANSI Common Lisp ยังคงมีให้เห็นทั่วโลก
  • ACL2หรือ "A Computational Logic for Applicative Common Lisp" ซึ่งเป็นรูปแบบประยุกต์ (ไม่มีผลข้างเคียง) ของ Common LISP ACL2 เป็นทั้งภาษาโปรแกรมที่สามารถสร้างแบบจำลองระบบคอมพิวเตอร์ และเป็นเครื่องมือที่ช่วยพิสูจน์คุณสมบัติของแบบจำลองเหล่านั้น
  • Clojureซึ่งเป็นภาษาถิ่นล่าสุดของ Lisp ซึ่งคอมไพล์ไปยังเครื่องเสมือน Javaและเน้นเฉพาะที่การ ทำงาน พร้อมกัน
  • Game Oriented Assembly Lisp (หรือ GOAL) เป็นภาษาการเขียนโปรแกรมวิดีโอเกมที่พัฒนาโดย Andy Gavin และทีมJak และ Daxterที่Naughty Dog มันถูกเขียนโดยใช้ Allegro Common Lisp และใช้ในการพัฒนาชุดเกม Jak และ Daxterทั้งหมด
  • Chialisp ภาษาระดับสูงที่รวบรวมลงไปที่ CLVM สภาพแวดล้อมการเขียนโปรแกรมแบบ on-chain ใน Chia blockchain

2000 ถึงปัจจุบัน

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

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

ในปี 2010 มีการใช้งาน Common Lisp ที่ได้รับการดูแลอย่างแข็งขัน 11 แบบ [34] Scieneer Common Lisp เป็นการใช้งานเชิงพาณิชย์แบบใหม่ที่แยกจาก CMUCL โดยมีการเปิดตัวครั้งแรกในปี 2545

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

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

ชุมชน Scheme มีการใช้งานมากกว่ายี่สิบรายการ การใช้งานใหม่ที่สำคัญหลายอย่าง (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) ได้รับการพัฒนาขึ้นในช่วงทศวรรษ 2000 (ทศวรรษ) รายงาน ฉบับปรับปรุง5เรื่อง Algorithmic Language Scheme [36]มาตรฐานของ Scheme ได้รับการยอมรับอย่างกว้างขวางในชุมชน Scheme กระบวนการร้องขอการดำเนินการได้สร้างไลบรารีและส่วนขยายเสมือนมาตรฐานจำนวนมากสำหรับ Scheme ชุมชนผู้ใช้ของการปรับใช้ Scheme แต่ละรายการยังคงเติบโต กระบวนการมาตรฐานภาษาใหม่เริ่มต้นขึ้นในปี 2546 และนำไปสู่ ​​R 6มาตรฐาน RS Scheme ในปี 2550 การใช้ Scheme ทางวิชาการในการสอนวิทยาการคอมพิวเตอร์ดูเหมือนจะลดลงบ้าง มหาวิทยาลัยบางแห่งไม่ใช้ Scheme ในหลักสูตรเบื้องต้นเกี่ยวกับวิทยาการคอมพิวเตอร์อีกต่อไป [37] [38]ตอนนี้ MIT ใช้Pythonแทน Scheme สำหรับ โปรแกรม วิทยาการคอมพิวเตอร์ ระดับปริญญาตรี และ MITx หลักสูตรออนไลน์เปิดขนาดใหญ่ [39] [40]

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

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

ภาษาหลัก

Common Lisp and Schemeเป็นตัวแทนของการพัฒนา Lisp สองสายหลัก ภาษาเหล่านี้รวมตัวเลือกการออกแบบที่แตกต่างกันอย่างมาก

Common Lispเป็นตัวตายตัวแทนของMaclisp อิทธิพลหลักคือLisp Machine Lisp , Maclisp, NIL , S-1 Lisp , Spice Lispและ Scheme [41]มีคุณลักษณะหลายอย่างของ Lisp Machine Lisp (ภาษาถิ่นขนาดใหญ่ที่ใช้ในการเขียนโปรแกรมLisp Machines ) แต่ได้รับการออกแบบมาเพื่อให้สามารถใช้งานได้อย่างมีประสิทธิภาพบนคอมพิวเตอร์ส่วนบุคคลหรือเวิร์กสเตชัน Common Lisp เป็นภาษาการเขียนโปรแกรมเอนกประสงค์และมีมาตรฐานภาษาขนาดใหญ่รวมถึงชนิดข้อมูลในตัว ฟังก์ชัน มาโครและองค์ประกอบภาษาอื่นๆ และระบบอ็อบเจ็กต์ ( Common Lisp Object System ) Common Lisp ยังยืมคุณสมบัติบางอย่างจาก Scheme เช่นขอบเขตคำ ศัพท์ และ การ ปิดคำศัพท์ การใช้งาน Lisp ทั่วไปพร้อมใช้งานสำหรับการกำหนดเป้าหมายแพลตฟอร์มต่างๆ เช่นLLVM [ 42 ] Java virtual machine [ 43] x86-64, PowerPC, Alpha, ARM, Motorola 68000 และ MIPS [44]และระบบปฏิบัติการเช่น Windows , macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD และ Heroku [45]

Scheme เป็นภาษาถิ่นของภาษา Lisp ที่คิดค้นโดยGuy L. Steele Jr.และGerald Jay Sussman ได้รับการออกแบบมาให้มีความหมายที่ชัดเจนและเรียบง่ายเป็นพิเศษ และมีวิธีการสร้างนิพจน์ที่แตกต่างกันเล็กน้อย ได้รับการออกแบบมาก่อนกว่า Common Lisp ประมาณหนึ่งทศวรรษSchemeคือการออกแบบที่เรียบง่ายกว่า มีชุดคุณสมบัติมาตรฐานที่เล็กกว่ามาก แต่มีคุณสมบัติการใช้งานบางอย่าง (เช่นการเพิ่มประสิทธิภาพ tail-callและความต่อเนื่อง ทั้งหมด) ไม่ได้ระบุไว้ใน Common Lisp กระบวนทัศน์การเขียนโปรแกรมที่หลากหลาย รวมถึงรูปแบบความจำเป็น การทำงาน และการส่งข้อความ ค้นหาการแสดงออกที่สะดวกใน Scheme Scheme ยังคงพัฒนาต่อไปด้วยชุดมาตรฐาน (Revised n Report on the Algorithmic Language Scheme) และชุดของScheme Requests for Implementation

Clojureเป็นภาษาถิ่นล่าสุดของ Lisp ที่กำหนดเป้าหมายไปยังJava virtual machine เป็นหลัก และCommon Language Runtime (CLR), Python VM, Ruby VM YARVและคอมไพล์เป็นJavaScript มันถูกออกแบบให้เป็นภาษาที่ใช้งานทั่วไปในทางปฏิบัติ Clojure ดึงอิทธิพลจำนวนมากจากHaskellและให้ความสำคัญกับความไม่เปลี่ยนรูปอย่างมาก [46] Clojure ให้การเข้าถึงเฟรมเวิร์กและไลบรารี Java พร้อมคำแนะนำประเภทที่เป็นตัวเลือกและ การ อนุมานประเภทเพื่อให้การเรียกใช้ Java สามารถหลีกเลี่ยงการสะท้อนและเปิดใช้งานการดำเนินการดั้งเดิมอย่างรวดเร็ว Clojure ไม่ได้ออกแบบมาให้เข้ากันได้กับภาษา Lisp อื่นๆ[47]

นอกจากนี้ ภาษา Lisp ยังถูกใช้เป็นภาษาสคริปต์ ในแอปพลิเคชันต่างๆ ด้วย Emacs Lispที่รู้จักกันดีที่สุดใน โปรแกรมแก้ไข Emacs , AutoLISPและVisual Lisp ที่ใหม่กว่า ในAutoCAD , Nyquist in Audacityและ Scheme ในLilyPond ขนาดที่เล็กของล่าม Scheme ที่มีประโยชน์ทำให้เป็นที่นิยมโดยเฉพาะสำหรับการเขียนสคริปต์แบบฝัง ตัวอย่าง ได้แก่SIODและTinySchemeซึ่งทั้งสองอย่างนี้ได้รับการฝังเรียบร้อยแล้วในตัว ประมวลผลภาพ GIMPภายใต้ชื่อสามัญ "Script-fu" [48]LIBREP ซึ่งเป็นล่าม Lisp โดย John Harper ซึ่งเดิมใช้ ภาษา Emacs Lispได้ถูกฝังไว้ในโปรแกรมจัดการหน้าต่างSawfish [49]

ภาษาถิ่นที่ได้มาตรฐาน

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

นวัตกรรมทางภาษา

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

เงื่อนไขที่ใช้ ไวยากรณ์ if–then–elseถูกคิดค้นโดย McCarthy ในบริบทของ Fortran เขาเสนอให้รวมไว้ในALGOLแต่ไม่ได้เป็นส่วนหนึ่งของข้อกำหนดAlgol 58 สำหรับ Lisp นั้น McCarthy ใช้โครงสร้างทั่วไปมากกว่า [51] Algol 60หยิบif–then–else ขึ้นมา และเผยแพร่ให้เป็นที่รู้จัก

Lisp มีอิทธิพลอย่างมากต่อAlan Kayหัวหน้าทีมวิจัยที่พัฒนาSmalltalkที่Xerox PARC ; และในทางกลับกัน Lisp ก็ได้รับอิทธิพลจาก Smalltalk โดยภาษาถิ่นต่อมาใช้คุณลักษณะการเขียนโปรแกรมเชิงวัตถุ (คลาสการสืบทอด การห่อหุ้มอินสแตนซ์ การส่งข้อความ ฯลฯ) ในปี 1970 ระบบ ออบเจ็กต์ Flavoursได้แนะนำแนวคิดเรื่องการสืบทอดและการผสมหลายรายการ Common Lisp Object System ให้ การสืบทอดหลายแบบ multimethods ที่มีการกระจายหลายตัว และ ฟังก์ชันทั่วไปชั้นหนึ่ง ทำให้ได้รูปแบบ ไดนามิกที่ยืดหยุ่นและทรงพลัง. มันทำหน้าที่เป็นเทมเพลตสำหรับระบบออบเจ็กต์ Lisp (รวมถึงScheme ) ที่ตามมาหลายระบบ ซึ่งมักจะถูกนำไปใช้ผ่านโปรโตคอล metaobjectซึ่งเป็นการออกแบบ metacircular แบบสะท้อนแสง ซึ่งระบบอ็อบเจ็กต์ถูกกำหนดโดยตัวมันเอง: Lisp เป็นเพียงภาษาที่สองรองจาก Smalltalk (และยังคงเป็นหนึ่งในไม่กี่ภาษา) ที่จะมีระบบ metaobject ดังกล่าว หลายปีต่อมา Alan Kay แนะนำว่าเป็นผลมาจากการบรรจบกันของคุณสมบัติเหล่านี้ มีเพียง Smalltalk และ Lisp เท่านั้นที่ถือได้ว่าเป็นระบบการเขียนโปรแกรมเชิงวัตถุที่คิดขึ้นอย่างเหมาะสม [52]

Lisp นำเสนอแนวคิดของการรวบรวมขยะอัตโนมัติซึ่งระบบจะทำการ ค้นหาหน่วยความ จำที่ไม่ได้ใช้ ความก้าวหน้าในอัลกอริธึมการรวบรวมขยะที่ทันสมัย ​​เช่น การรวบรวมขยะรุ่นต่างๆ ได้รับการกระตุ้นโดยการใช้ Lisp [53]

Edsger W. Dijkstra ใน การบรรยาย รางวัล Turing Awardปี 1972 กล่าวว่า

"ด้วยหลักการพื้นฐานไม่กี่ประการที่รากฐานของมัน [LISP] ได้แสดงให้เห็นถึงความเสถียรที่โดดเด่น นอกจากนั้น LISP ยังเป็นผู้ให้บริการในด้านการใช้งานคอมพิวเตอร์ที่ซับซ้อนที่สุดของเรา LISP ได้รับการอธิบายอย่างติดตลกว่า " วิธีที่ชาญฉลาดที่สุดในการใช้คอมพิวเตอร์ในทางที่ผิด” ฉันคิดว่าคำอธิบายนั้นเป็นคำชมที่ยอดเยี่ยมเพราะมันถ่ายทอดรสชาติของการปลดปล่อยอย่างเต็มที่: มันได้ช่วยเพื่อนมนุษย์ที่มีพรสวรรค์ที่สุดของเราหลายคนในการคิดความคิดที่เป็นไปไม่ได้ก่อนหน้านี้" [54]

ส่วนใหญ่เนื่องจากความต้องการทรัพยากรที่เกี่ยวข้องกับฮาร์ดแวร์คอมพิวเตอร์ในยุคแรก (รวมถึงไมโครโปรเซสเซอร์รุ่นแรก) Lisp จึงไม่ได้รับความนิยมนอก ชุมชน AIเท่ากับFortranและภาษา C ที่สืบทอดมาจากALGOL เนื่องจากความเหมาะสมในการใช้งานที่ซับซ้อนและไดนามิก Lisp จึงได้รับความนิยมอีกครั้งในช่วงปี 2010 [55]

ไวยากรณ์และความหมาย

หมายเหตุ : ตัวอย่างของบทความนี้เขียนด้วยCommon Lisp (แม้ว่าส่วนใหญ่จะใช้ได้ในScheme )

นิพจน์เชิงสัญลักษณ์ (S-expressions)

Lisp เป็น ภาษา ที่เน้นการแสดงออก ไม่เหมือนกับภาษาอื่นๆ ส่วนใหญ่ ไม่มีการแบ่งแยกระหว่าง "สำนวน" และ"คำสั่ง" ; [ พิรุธ ]รหัสและข้อมูลทั้งหมดถูกเขียนเป็นนิพจน์ เมื่อนิพจน์ได้ รับการ ประเมิน นิพจน์จะ สร้างค่า (ใน Common Lisp อาจมีหลายค่า) ซึ่งสามารถฝังลงในนิพจน์อื่นได้ แต่ละค่าสามารถเป็นชนิดข้อมูลใดก็ได้

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

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

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

รายการ

รายการ Lisp เขียนด้วยองค์ประกอบที่คั่นด้วยช่องว่างและล้อมรอบด้วยวงเล็บ ตัวอย่างเช่นเป็นรายการที่มีองค์ประกอบเป็นสามอะตอม , , และ. ค่าเหล่านี้ถูกพิมพ์โดยนัย: เป็นจำนวนเต็มสองจำนวนตามลำดับและชนิดข้อมูลเฉพาะ Lisp ที่เรียกว่า "สัญลักษณ์" และไม่จำเป็นต้องประกาศเช่นนั้น (1 2 foo) 12foo

รายการว่าง()จะแสดงเป็นอะตอมพิเศษnilด้วย นี่เป็นเอนทิตีเดียวใน Lisp ซึ่งเป็นทั้งอะตอมและรายการ

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

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

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

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

ประเมิน ในรายการ โปรดทราบว่าอาร์กิวเมนต์ที่สามคือรายการ สามารถซ้อนรายการได้ (1 2 (3 4))

ตัวดำเนินการ

ตัวดำเนินการเลขคณิตได้รับการปฏิบัติในทำนองเดียวกัน การแสดงออก

 ( +  1  2  3  4 )

ประเมินเป็น 10 ค่าเทียบเท่าภายใต้สัญลักษณ์มัดจะเป็น " " 1 + 2 + 3 + 4

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

 ( รวม x )

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

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

 ( ถ้า ไม่มี
     ( รายการ 1  2  "foo" ) 
     ( รายการ 3  4  "บาร์" ))

ประเมินเป็น. แน่นอน สิ่งนี้จะมีประโยชน์มากกว่าถ้านิพจน์ที่ไม่สำคัญถูกแทนที่ด้วย. (3 4 "bar")nil

เสียงกระเพื่อมยังจัดเตรียมตัวดำเนินการเชิงตรรกะและและหรือไม่ ตัวดำเนินการและและหรือจะทำการประเมินการลัดวงจรและจะคืนค่าอาร์กิวเมนต์แรกเป็นศูนย์และไม่ใช่ศูนย์ตามลำดับ

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

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

นิพจน์แลมบ์ดาและคำจำกัดความของฟังก์ชัน

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

 ( แลมบ์ดา ( arg )  ( +  arg  1 ))

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

 (( แลมบ์ดา ( arg )  ( +  arg  1 ))  5 )

ประเมินเป็น6. ที่นี่ เรากำลังสร้างแอปพลิเคชันฟังก์ชัน: เราเรียกใช้ฟังก์ชันที่ไม่ระบุตัวตนโดยส่งค่า 5 ไปให้ฟังก์ชันนั้น

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

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

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

 ( setf  ( fdefinition  'f )  #' ( แลมบ์ดา ( a )  ( block  f  b... )))

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

อะตอม

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

ความแตกต่างที่สำคัญระหว่างอะตอมและรายการคืออะตอมนั้นไม่เปลี่ยนรูปและมีลักษณะเฉพาะ อะตอมสองอะตอมที่ปรากฏในสถานที่ต่างกันในซอร์สโค้ด แต่เขียนในลักษณะเดียวกันทุกประการเพื่อเป็นตัวแทนของวัตถุเดียวกัน[ ต้องการการอ้างอิง ]ในขณะที่แต่ละรายการเป็นวัตถุแยกต่างหากที่สามารถเปลี่ยนแปลงได้โดยอิสระจากรายการอื่น และสามารถแยกความแตกต่างออกจากรายการอื่นโดย ตัวดำเนินการเปรียบเทียบ

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

ข้อเสียและรายการ

แผนภาพ กล่องและตัวชี้สำหรับรายการ (42 69 613)

รายการเสียงกระเพื่อมถูกนำมาใช้เป็นรายการที่เชื่อมโยงโดยลำพัง [57]แต่ละเซลล์ของรายการนี้เรียกว่าข้อเสีย (ใน Scheme คู่ ) และประกอบด้วย พ อย น์ เตอร์ สองตัว เรียกว่าcarและcdr เหล่านี้เทียบเท่ากับ เขตข้อมูล dataและ ที่ nextกล่าวถึงในบทความที่เชื่อมโยงตามลำดับ

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

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

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

เนื่องจากข้อเสียและรายการเป็นสากลในระบบ Lisp จึงเป็นความเข้าใจผิดทั่วไปว่าเป็นโครงสร้างข้อมูลเดียวของ Lisp อันที่จริง Lisps แบบธรรมดาทั้งหมดมีโครงสร้างข้อมูลอื่น ๆ ทั้งหมด ยกเว้น Lisps เช่น vectors ( arrays ) hash tablesโครงสร้าง และอื่นๆ

S-expressions เป็นตัวแทนของรายการ

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

ขั้นตอนการประมวลผลรายการ

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

 ( รายการ 1  2  'a  3 ) 
 ;เอาต์พุต: (1 2 a 3)
 ( รายการ 1  ' ( 2  3 )  4 ) 
 ; เอาต์พุต: (1 (2 3) 4)

เนื่องจากวิธีการสร้างรายการจากcons pairsขั้นconsตอนสามารถใช้เพื่อเพิ่มองค์ประกอบที่ด้านหน้าของรายการ โปรดทราบว่าconsขั้นตอนไม่สมมาตรในการจัดการอาร์กิวเมนต์รายการ เนื่องจากวิธีการสร้างรายการ

 ( ข้อเสีย 1  ' ( 2  3 )) 
 ;เอาต์พุต: (1 2 3)
 ( ข้อเสีย ' ( 1  2 )  ' ( 3  4 )) 
 ;เอาต์พุต: ((1 2) 3 4)

ขั้นappendตอนจะผนวกรายการสองรายการ (หรือมากกว่า) ต่อกัน เนื่องจากรายการ Lisp เป็นรายการที่เชื่อมโยง การต่อท้ายสองรายการจึงมีความซับซ้อนของเวลาแบบ ไม่มีซีมโทติก

 ( ต่อท้าย ' ( 1  2 )  ' ( 3  4 )) 
 ;เอาต์พุต: (1 2 3 4)
 ( ต่อท้าย ' ( 1  2  3 )  ' ()  ' ( a )  ' ( 5  6 )) 
 ;เอาต์พุต: (1 2 3 a 5 6)

โครงสร้างที่ใช้ร่วมกัน

รายการ Lisp เป็นรายการที่เชื่อมโยงอย่างง่าย สามารถแชร์โครงสร้างระหว่างกันได้ กล่าวคือ สองรายการสามารถมีtail เดียวกัน หรือลำดับสุดท้ายของ cons ตัวอย่างเช่น หลังจากเรียกใช้ Common Lisp code ต่อไปนี้:

( setf  foo  ( รายการ 'a  '  b'c )) 
( แถบsetf  ( ข้อเสีย'x ( cdr foo )))    

รายการfooและbarเป็นและตามลำดับ อย่างไรก็ตาม ส่วนท้ายมีโครงสร้างเหมือนกันในทั้งสองรายการ ไม่ใช่สำเนา เซลล์ข้อเสียที่ชี้ไปและอยู่ในตำแหน่งหน่วยความจำเดียวกันสำหรับทั้งสองรายการ (a b c)(x b c)(b c)bc

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

 ( setf  ( สาม foo )  ' ห่าน)

สิ่งนี้จะเปลี่ยนfooเป็นแต่ด้วยเหตุนี้จึงเปลี่ยนเป็น– ผลลัพธ์ที่ไม่คาดคิด นี่อาจเป็นสาเหตุของจุดบกพร่อง และฟังก์ชันที่เปลี่ยนแปลงข้อโต้แย้งของพวกเขาได้รับการบันทึกว่าเป็นอันตรายด้วยเหตุนี้เอง (a b goose)bar(x b goose)

ผู้สนใจรักการเขียนโปรแกรมเชิงฟังก์ชันหลีกเลี่ยงฟังก์ชันการทำลายล้าง ในภาษา Scheme ซึ่งชอบรูปแบบการใช้งาน ชื่อของฟังก์ชันการทำลายล้างจะมีเครื่องหมายอัศเจรีย์เตือนหรือ "ปัง" เช่นset-car!(read set car bang ) ซึ่งจะแทนที่ข้อเสียของรถยนต์ ในภาษาถิ่นทั่วไป ฟังก์ชันทำลายล้างเป็นเรื่องธรรมดา เทียบเท่ากับset-car!ชื่อrplacaสำหรับ "replace car" อย่างไรก็ตาม ฟังก์ชันนี้ไม่ค่อยพบเห็น เนื่องจาก Common Lisp มีสิ่งอำนวยความสะดวกพิเศษsetfเพื่อให้ง่ายต่อการกำหนดและใช้ฟังก์ชันการทำลายล้าง รูปแบบที่พบบ่อยใน Common Lisp คือการเขียนโค้ดตามหน้าที่ (ไม่มีการเรียกแบบทำลายล้าง) เมื่อสร้างต้นแบบ จากนั้นจึงเพิ่มการเรียกแบบทำลายล้างเป็นการปรับให้เหมาะสมซึ่งสามารถทำได้อย่างปลอดภัย

แบบประเมินตนเองและการอ้างอิง

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

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

ทั้ง Common Lisp และ Scheme ยังรองรับตัว ดำเนินการ backquote (เรียกว่าquasiquoteใน Scheme) ซึ่งป้อนด้วย`อักขระ ( เน้นหนัก ) ซึ่งเกือบจะเหมือนกับอัญประกาศธรรมดา ยกเว้นอนุญาตให้ประเมินนิพจน์และค่าของนิพจน์นั้นถูกสอดแทรกในรายการที่ยกมาโดยใช้เครื่องหมายจุลภาค, unquoteและ ตัว ดำเนินการ,@ ประกบ ด้วยเครื่องหมายจุลภาค หากตัวแปรsnueมีค่าให้ประเมินเป็นในขณะที่ประเมินเป็น Backquote มักใช้ในการกำหนดการขยายมาโคร [59] [60](bar baz)`(foo ,snue)(foo (bar baz))`(foo ,@snue)(foo bar baz)

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

( defun  should-be-constant  ( ) 
  ' ( หนึ่ง สอง สาม))

( ให้ (( สิ่ง ( ควรจะคงที่))) 
  ( setf  ( สิ่งที่สาม ) 'แปลกประหลาด)) ; แย่!    

( ควรเป็นค่าคงที่)    ; ผลตอบแทน (หนึ่งสองแปลกประหลาด)

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

Douglas Hofstadter (ในGödel, Escher, Bach ) และคนอื่น ๆ ตั้งข้อสังเกตว่าการทำให้ Lisp เป็นทางการของใบเสนอราคาได้รับการกล่าวถึงว่าเป็นตัวอย่างของแนวคิด เชิง ปรัชญา เกี่ยวกับ การอ้างอิงตนเอง

ขอบเขตและการปิด

กลุ่ม Lisp แบ่งการใช้ขอบเขตแบบไดนามิกหรือแบบคงที่ (aka lexical) 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 สามารถทำกับโค้ดได้ ในทางตรงกันข้าม ในภาษาอื่นๆ ส่วนใหญ่ เอาต์พุตของ parser จะอยู่ภายในการใช้งานภาษาเท่านั้น และโปรแกรมเมอร์ไม่สามารถจัดการได้

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

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

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

การประเมินและการอ่าน–eval–print loop

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

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

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

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

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

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

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

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

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

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

โครงสร้างการควบคุม

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

โปรแกรมเมอร์ในภาษา Scheme มักจะแสดงการวนซ้ำโดยใช้การเรียกซ้ำส่วนท้าย ความคล้ายคลึงกันของ Scheme ในวิทยาการคอมพิวเตอร์เชิงวิชาการทำให้นักเรียนบางคนเชื่อว่าการเรียกซ้ำหางเป็นวิธีเดียวหรือเป็นวิธีการเขียนซ้ำในภาษา Lisp ธรรมดาที่สุดเท่านั้น หรือเป็นวิธีเดียวที่ผิด ภาษา Lisp ที่มองเห็นได้ทั่วไปทั้งหมดมีโครงสร้างการวนซ้ำแบบจำเป็น ตั้งแต่doลูปของ Scheme ไปจนถึงนิพจน์ที่ซับซ้อนของCommon Lisp loopนอกจากนี้ ประเด็นสำคัญที่ทำให้สิ่งนี้เป็นวัตถุประสงค์มากกว่าเรื่องส่วนตัวคือ Scheme กำหนดข้อกำหนดเฉพาะสำหรับการจัดการการเรียกหางและด้วยเหตุนี้เหตุผลที่โดยทั่วไปแนะนำให้ใช้การเรียกซ้ำส่วนท้ายสำหรับ Scheme ก็คือการฝึกฝนนั้นได้รับการสนับสนุนอย่างชัดเจนจากคำจำกัดความของภาษา ในทางตรงกันข้าม ANSI Common Lisp ไม่ต้องการ[62]การเพิ่มประสิทธิภาพที่เรียกกันทั่วไปว่าการขจัดการเรียกหาง ดังนั้น ข้อเท็จจริงที่ว่ารูปแบบการเรียกซ้ำส่วนท้ายเป็นการแทนที่แบบไม่เป็นทางการสำหรับการใช้โครงสร้างการวนซ้ำ แบบเดิม (เช่นdo, dolistหรือloop) จึงไม่สนับสนุน[63]ใน Common Lisp ไม่ใช่แค่เรื่องของการกำหนดลักษณะโวหาร แต่อาจเป็นหนึ่งในประสิทธิภาพ (ตั้งแต่ การเรียกหางที่ชัดเจนใน Common Lisp อาจไม่สามารถคอมไพล์เป็นการกระโดด แบบง่าย ๆ ) และความถูกต้องของโปรแกรม (เนื่องจากการเรียกซ้ำของหางอาจเพิ่มการใช้สแต็กใน Common Lisp ซึ่งมีความเสี่ยงกองล้น ).

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

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

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

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

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

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

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

สิ่งนี้ใช้+ฟังก์ชันกับคู่ขององค์ประกอบรายการแต่ละคู่ ให้ผลลัพธ์ (11 22 33 44 55)

ตัวอย่าง

ต่อไปนี้คือตัวอย่างโค้ด Lisp ทั่วไป

โปรแกรม " Hello, World! " พื้นฐาน:

( พิมพ์ "สวัสดีชาวโลก!" )

ไวยากรณ์ Lisp ยืมตัวเองตามธรรมชาติเพื่อเรียกซ้ำ ปัญหาทางคณิตศาสตร์ เช่น การแจงนับของเซตที่กำหนดแบบเรียกซ้ำนั้นง่ายต่อการแสดงในสัญกรณ์นี้ ตัวอย่างเช่น ในการประเมินแฟกทอเรียล ของตัวเลข :

( defun แฟค  ทอเรียล ( n ) 
    ( if  ( zerop  n )  1 
        ( *  n  ( แฟค ทอเรียล ( 1-  n ))))

การใช้งานทางเลือกอื่นใช้พื้นที่สแต็กน้อยกว่าเวอร์ชันก่อนหน้าหากระบบ Lisp พื้นฐานปรับการเรียกซ้ำหาง ให้เหมาะสม :

( defun  factorial  ( n  &ตัวเลือก ( acc  1 )) 
    ( if  ( zerop  n )  acc 
        ( factorial  ( 1-  n )  ( *  acc  n ))))

เปรียบเทียบตัวอย่างด้านบนด้วยเวอร์ชันวนซ้ำซึ่งใช้มาโคร ของCommon Lisp :loop

( defun  factorial  ( n ) 
    ( วนซ้ำ สำหรับ i  จาก 1  ถึง n 
        สำหรับ fac  =  1  จากนั้น ( *  fac  i ) 
        ในที่สุด ( return  fac )))

ฟังก์ชันต่อไปนี้จะกลับรายการ (ฟังก์ชัน ย้อนกลับในตัวของ Lisp ทำสิ่งเดียวกัน)

( defun  -reverse  ( list ) 
    ( let  (( return-value )) 
      ( dolist  ( e  list )  ( push  e  return-value )) 
      return-value ))

ระบบวัตถุ

ระบบและโมเดลอ็อบเจ็กต์ต่างๆ ได้ถูกสร้างขึ้นบน ข้าง หรือใน Lisp รวมไปถึง:

ดูเพิ่มเติม

อ้างอิง

  1. ^ "แนะนำตัว" . คู่มือจูเลีย อ่านเอกสาร เก็บถาวรจากต้นฉบับเมื่อ 2016-04-08 . สืบค้นเมื่อ2016-12-10 .
  2. ^ "คำถาม & คำตอบภาษา Wolfram" . วิจัยวุลแฟรม สืบค้นเมื่อ2016-12-10 .
  3. เอ็ดวิน ดี. ไรลีย์ (2003). เหตุการณ์สำคัญในวิทยาการคอมพิวเตอร์และเทคโนโลยีสารสนเทศ กลุ่มสำนักพิมพ์กรีนวูด หน้า 156–157. ISBN 978-1-57356-521-9.
  4. ^ "SICP: คำนำ" . เก็บถาวรจากต้นฉบับเมื่อ 2001-07-27 Lisp เป็นผู้รอดชีวิต มีการใช้งานมาประมาณหนึ่งในสี่ของศตวรรษ ในบรรดาภาษาโปรแกรมที่ใช้งานมีเพียง Fortran เท่านั้นที่มีอายุการใช้งานยาวนานขึ้น
  5. ^ "บทสรุป" . เก็บถาวรจากต้นฉบับเมื่อ 2014-04-03 . สืบค้นเมื่อ2014-06-04 .
  6. ^ "ศิลปะของล่ามหรือคอมเพล็กซ์โมดูลาร์ (Parts Zero, One และ Two), Part Zero, P. 4 " ห้องสมุดเอ็มไอที hdl : 1721.1/6094 . สืบค้นเมื่อ2020-08-01 .
  7. ^ "ภาษาโปรแกรมยอดนิยมด้านปัญญาประดิษฐ์" . ปัญญาประดิษฐ์ . อปท. เก็บถาวรจากต้นฉบับเมื่อ 2020-10-30 . ดึงข้อมูลเมื่อ2021-02-15 .
  8. พอล เกรแฮม. "การแก้แค้นของพวกเนิร์ด" . ดึงข้อมูลเมื่อ2013-03-14
  9. ชิสนัลล์, เดวิด (2011-01-12). ภาษาโปรแกรมที่มีอิทธิพล ตอนที่ 4: เสียงกระเพื่อม
  10. ^ โจนส์ โรบิน; เมย์นาร์ด, ไคลฟ์; สจ๊วต, เอียน (6 ธันวาคม 2555). ศิลปะแห่งการเขียนโปรแกรม Lisp สื่อวิทยาศาสตร์และธุรกิจของสปริงเกอร์ หน้า 2. ISBN 9781447117193.
  11. จอห์น แมคคาร์ธี. "ฟังก์ชันแบบเรียกซ้ำของนิพจน์เชิงสัญลักษณ์และการคำนวณด้วยเครื่อง ส่วนที่ 1 " เก็บถาวรจากต้นฉบับเมื่อ 2013-10-04 . สืบค้นเมื่อ2006-10-13 .
  12. เดวิด แคนฟิลด์ สมิธ. "คู่มือผู้ใช้ MLISP" (PDF ) สืบค้นเมื่อ2006-10-13 .
  13. จอห์น แม็กคาร์ธี (12 กุมภาพันธ์ พ.ศ. 2522) "ประวัติของ Lisp: ห้องปฏิบัติการปัญญาประดิษฐ์" (PDF )
  14. ^ Paul Grahamใน Hackers & Painters , p. 185
  15. จอห์น แมคคาร์ธี. "LISP ดึกดำบรรพ์ - ฤดูร้อน 2499 ถึงฤดูร้อน 2501" . สืบค้นเมื่อ2010-03-14 .
  16. ทิม ฮาร์ตและไมค์ เลวิน “AI Memo 39-คอมไพเลอร์ตัวใหม่” (PDF) . เก็บถาวรจากต้นฉบับ(PDF)เมื่อ 2020-12-13 . สืบค้นเมื่อ2019-03-18 .
  17. แม็กคาร์ธี จอห์น; อับราฮัม, พอล ดับเบิลยู.; เอ็ดเวิร์ดส์, แดเนียล เจ.; ฮาร์ต, ทิโมธีพี.; Levin, Michael I. (1962, (พิมพ์ครั้งที่ 15, 1985)) LISP 1.5 Programmer's Manual (PDF) (ฉบับที่สอง) หน้า คำนำ {{cite book}}: ตรวจสอบค่าวันที่ใน: |date=( ช่วย )
  18. ^ ขนาดคำ 36 บิตของ PDP-6 / PDP-10ได้รับอิทธิพลจากประโยชน์ของการมีพอยน์เตอร์ Lisp 18 บิตสองตัวในคำเดียว ปีเตอร์ เจ. เฮอร์ลีย์ (18 ตุลาคม 1990) "ประวัติของ TOPS หรือชีวิตใน Fast ACs" . กลุ่มข่าวalt.folklore.computers Usenet : [email protected] โครงการ PDP-6 เริ่มต้นในต้นปี 2506 โดยเป็นเครื่องจักรแบบ 24 บิต LISP เติบโตเป็น 36 บิต ซึ่งเป็นเป้าหมายการออกแบบ 
  19. ^ เสียงกระเพื่อมสามัญ:(defun f (x) x)
    โครงการ:(define f (lambda (x) x))or(define (f x) x)
  20. ^ แม็กคาร์ธี เจ. ; เบรย์ตัน, อาร์. ; เอ็ดเวิร์ดส์, ดี. ; ฟ็อกซ์, พี. ; โฮเดส, แอล. ; ลัคแฮม, ดี. ; มาลิง, K. ; ปาร์ค, ดี. ; รัสเซล, เอส. (มีนาคม 2503) "คู่มือโปรแกรมเมอร์ LISP I" (PDF ) บอสตันรัฐแมสซาชูเซตส์ : Artificial Intelligence Group, MIT Computation Center and Research Laboratory. เก็บถาวรจากต้นฉบับ(PDF)เมื่อ 2010-07-17 {{cite journal}}:อ้างอิงวารสารต้องการ|journal=( ความช่วยเหลือ )เข้าถึงเมื่อ 11 พฤษภาคม 2010.
  21. แม็กคาร์ธี จอห์น; อับราฮัม, พอล ดับเบิลยู.; เอ็ดเวิร์ดส์, แดเนียล เจ.; ฮาร์ต, ทิโมธีพี.; เลวิน, ไมเคิล ไอ. (1985) [1962] LISP 1.5 Programmer's Manual (PDF) (ฉบับที่ 2) สำนักพิมพ์เอ็มไอที ISBN  0-262-13011-4.
  22. ^ กวม ลินน์ เอช.; ดิฟเฟิล, วิทฟิลด์. คู่มือการใช้งาน Stanford LISP 1.6 (PDF )
  23. ^ "คู่มืออ้างอิง Maclisp" . 3 มีนาคม 2522 เก็บถาวรจากต้นฉบับเมื่อ 2550-2557
  24. เทเทลมัน, วอร์เรน (1974). คู่มืออ้างอิง InterLisp (PDF ) เก็บถาวรจากต้นฉบับ(PDF) เมื่อ 2006-06-02 สืบค้นเมื่อ2006-08-19 .
  25. Outils de generation d'interfaces : etat de l'art et การจัดหมวดหมู่โดย H. El Mrabet
  26. Gerald Jay Sussman & Guy Lewis Steele Jr. (ธันวาคม 1975) "โครงการ: ล่ามสำหรับแคลคูลัสแลมบ์ดาขยาย" (PDF ) บันทึก ช่วยจำ AI MIT AIแล็บ เอไอเอ็ม-349 . สืบค้นเมื่อ23 ธันวาคม 2021 .
  27. ^ สตีล, กาย แอล. จูเนียร์ (1990). "วัตถุประสงค์" . Common Lisp the Language (ฉบับที่ 2) ISBN 0-13-152414-3.
  28. คันโทรวิทซ์ มาร์ค; มาร์โกลิน, แบร์รี่ (20 กุมภาพันธ์ พ.ศ. 2539) "ประวัติ: Lisp มาจากไหน" . คำถามที่พบบ่อย: Lisp คำถามที่พบบ่อย 2/7
  29. ^ "ISO/IEC 13816: 1997" . Iso.org 2550-10-01 . ดึงข้อมูลเมื่อ2013-11-15 .
  30. ^ "ISO/IEC 13816:2007" . Iso.org 2013-10-30 . ดึงข้อมูลเมื่อ2013-11-15 .
  31. ^ "กฎบัตร X3J13" .
  32. ^ "การสำรวจเส้นทางสู่เสียงกระเพื่อม" . เก็บถาวรจากต้นฉบับเมื่อ 2006-10-04 สืบค้นเมื่อ2006-10-13 .
  33. ^ "แนวโน้มสู่อนาคต" . คำถามที่พบบ่อย.org เก็บถาวรจากต้นฉบับเมื่อ 2013-06-03 . ดึงข้อมูลเมื่อ2013-11-15 .
  34. ไวน์เรบ, ดาเนียล. "การใช้งาน Lisp ทั่วไป: การสำรวจ " เก็บถาวรจากต้นฉบับเมื่อ 2012-04-21 . สืบค้นเมื่อ4 เมษายน 2555 .
  35. ^ "LISP50@OOPSLA" . Lisp50.org . ดึงข้อมูลเมื่อ2013-11-15 .
  36. ^ เอกสาร: มาตรฐาน: R5RS . schemrs.org (2012-01-11) สืบค้นเมื่อ 2013-07-17.
  37. ^ "เหตุใด MIT จึงใช้ python แทนโครงการสำหรับโปรแกรม CS ระดับปริญญาตรี " cemerick.com . 24 มีนาคม 2552 เก็บถาวรจากต้นฉบับเมื่อ 17 กันยายน 2553 . สืบค้นเมื่อ10 พฤศจิกายน 2556 .
  38. ^ โบรเดอร์ อีวาน (8 มกราคม 2551) "จุดจบของยุค" . mitadmissions.org . สืบค้นเมื่อ10 พฤศจิกายน 2556 .
  39. ^ "หลักสูตรระดับปริญญาตรีของ MIT EECS" www.eecs.mit.edu _ MIT วิศวกรรมไฟฟ้าและวิทยาการคอมพิวเตอร์ สืบค้นเมื่อ31 ธันวาคม 2018 .
  40. ^ "หลักสูตร Python เบื้องต้นของ MITx มียอดลงทะเบียน 1.2 ล้านแล้ว " เอ็มไอทีอีอีซี. MIT วิศวกรรมไฟฟ้าและวิทยาการคอมพิวเตอร์ สืบค้นเมื่อ31 ธันวาคม 2018 .
  41. ^ บทที่ 1.1.2 ประวัติ ANSI CL Standard
  42. ^ [1] Clasp คือการใช้งาน Lisp ทั่วไปที่ทำงานร่วมกับ C++ และใช้ LLVM สำหรับการคอมไพล์แบบทันเวลา (JIT) ไปยังโค้ดเนทีฟ
  43. ^ [2] "Armed Bear Common Lisp (ABCL) เป็นการนำภาษา Common Lisp ไปใช้อย่างเต็มรูปแบบซึ่งมีทั้งล่ามและคอมไพเลอร์ที่ทำงานใน JVM"
  44. ^ [3] เก็บถาวร 2018-06-22 ที่ Wayback Machine Common Lisp Implementations: A Survey
  45. ^ [4]การเปรียบเทียบการใช้งาน Common Lisp ที่พัฒนาอย่างแข็งขัน
  46. An In-Depth Look at Clojure Collections , เรียกข้อมูลเมื่อ 2012-06-24
  47. ^ "ปิดบังเหตุผล" . สืบค้นเมื่อ27 สิงหาคม 2019 . Clojure เป็น Lisp ที่ไม่ถูกจำกัดด้วยความเข้ากันได้แบบย้อนหลัง
  48. Script-fu In GIMP 2.4 , เรียกข้อมูลเมื่อ 2009-10-29
  49. ↑ librep ที่ Sawfish Wikia, สืบค้นเมื่อ 2009-10-29
  50. ^ "โครงการ IEEE" . IEEE 1178-1990 - มาตรฐาน IEEE สำหรับ Scheme Programming Language สืบค้นเมื่อ27 สิงหาคม 2019 .
  51. ^ "LISP ยุคก่อนประวัติศาสตร์ - ฤดูร้อน 2499 ถึงฤดูร้อน 2501" . ฉันคิดค้นนิพจน์แบบมีเงื่อนไขที่เกี่ยวข้องกับชุดกิจวัตรการเคลื่อนไหวทางกฎหมายของหมากรุกที่ฉันเขียนใน FORTRAN สำหรับ IBM 704 ที่ MIT ระหว่างปี 1957–58 ... กระดาษที่กำหนดนิพจน์แบบมีเงื่อนไขและเสนอการใช้งานใน Algol ถูกส่งไปยัง Communications of the ACM แต่ถูกลดระดับตามอำเภอใจเป็นจดหมายถึงบรรณาธิการ เพราะมันสั้นมาก
  52. ^ "ความหมายของ 'การเขียนโปรแกรมเชิงวัตถุ' ตามที่ดร. อลัน เคย์" . 2546-07-23. ฉันไม่เข้าใจแนวคิด LISP สัตว์ประหลาดของ metalanguage ที่จับต้องได้ แต่ได้ใกล้ชิดกับแนวคิดเกี่ยวกับภาษาที่ขยายได้ ... ขั้นตอนที่สองของสิ่งนี้คือการเข้าใจ LISP ในที่สุดแล้วใช้ความเข้าใจนี้เพื่อทำให้ดีขึ้น เล็กลง และมากขึ้น โครงสร้างที่ถูกผูกไว้อย่างมีประสิทธิภาพและล่าช้ากว่า ... สำหรับฉัน OOP หมายถึงเฉพาะการส่งข้อความ การเก็บรักษาและการป้องกันในเครื่อง และการซ่อนกระบวนการของรัฐ และการผูกมัดท้ายสุดของทุกสิ่ง สามารถทำได้ใน Smalltalk และ LISP อาจมีระบบอื่นที่เป็นไปได้ แต่ฉันไม่รู้
  53. ลีเบอร์แมน เฮนรี; Hewitt, Carl (มิถุนายน 2526), ​​"นักสะสมขยะตามเวลาจริงตามอายุการใช้งานของวัตถุ" , Communications of the ACM , 26 (6): 419–429, CiteSeerX 10.1.1.4.8633 , doi : 10.1145/358141.358147 , hdl : 1721.1/6335 , S2CID 14161480  
  54. ↑ Edsger W. Dijkstra (1972), โปรแกรมเมอร์ผู้ต่ำต้อย (EWD 340)(บรรยาย ACM Turing Award)
  55. ^ "ดูที่ Clojure และ Lisp Resurgence" .
  56. ^ "ไฟล์ศัพท์แสง - เสียงกระเพื่อม" . สืบค้นเมื่อ2006-10-13 .
  57. เซเบสตา, โรเบิร์ต ดับเบิลยู. (2012). ""2.4 Functional Programming: LISP";"6.9 List Types";"15.4 The First Functional Programming Language: LISP"" Concepts of Programming Languages ​​(print) (ฉบับพิมพ์ครั้งที่ 10) Boston, MA, USA: Addison-Wesley. pp. 47–52, 281–284, 677–680. ISBN 978-0-13-139531-2.
  58. ^ NB: สิ่งที่เรียกว่า "รายการประ" เป็นเพียง "รายการที่ไม่เหมาะสม" เพียงประเภทเดียวเท่านั้น อีกประเภทหนึ่งคือ "รายการแบบวงกลม" ซึ่งเซลล์ข้อเสียสร้างลูป โดยปกติจะแสดงโดยใช้ #n=(...) เพื่อแสดงเซลล์ข้อเสียเป้าหมายที่จะมีการอ้างอิงหลายรายการ และ #n# ใช้เพื่ออ้างถึงข้อเสียนี้ ตัวอย่างเช่น (#1=(ab) . #1#) ปกติจะถูกพิมพ์เป็น ((ab) ab) (โดยไม่เปิดใช้งานการพิมพ์โครงสร้างแบบวงกลม) แต่ทำให้การนำเซลล์ข้อเสียมาใช้ซ้ำนั้นชัดเจน #1=(ก . #1#) ปกติไม่สามารถพิมพ์ได้เนื่องจากเป็นรูปวงกลม แม้ว่าบางครั้ง (a...) จะแสดงขึ้น แต่ CDR ของเซลล์ข้อเสียที่กำหนดโดย #1= เป็นตัวมันเอง
  59. ^ "CSE 341: Scheme: Quote, Quasiquote และ Metaprogramming " Cs.washington.edu. 1999-02-22 . ดึงข้อมูลเมื่อ2013-11-15 .
  60. ^ Quasiquotation in Lisp Archived 2013-06-03 ที่ Wayback Machine , Alan Bawden
  61. ^ เวลาของการประเมิน - ส่วนขยายเสียงกระเพื่อมทั่วไป Gnu.org สืบค้นเมื่อ 2013-07-17.
  62. ^ 3.2.2.3 ข้อจำกัดทางความหมายใน Common Lisp HyperSpec
  63. ^ 4.3. Control Abstraction (Recursion vs. Iteration) ใน บทช่วย สอนเกี่ยวกับ Good Lisp Programming Styleโดย Kent Pitmanและ Peter Norvig , สิงหาคม, 1993
  64. ^ หน้า 17 ของ Bobrow 1986
  65. ^ Veitch, หน้า 108, 1988

อ่านเพิ่มเติม

ลิงค์ภายนอก

ประวัติศาสตร์
สมาคมและการประชุม
หนังสือและแบบฝึกหัด
สัมภาษณ์
  • สัมภาษณ์ประวัติโดยปากเปล่ากับ John McCarthyที่Charles Babbage Institute , University of Minnesota, Minneapolis แมคคาร์ธีกล่าวถึงบทบาทของเขาในการพัฒนาการแบ่งปันเวลาที่สถาบันเทคโนโลยีแมสซาชูเซตส์ นอกจากนี้ เขายังอธิบายถึงงานของเขาในด้านปัญญาประดิษฐ์ (AI) ซึ่งได้รับทุนจากสำนักงานโครงการวิจัยขั้นสูง ซึ่งรวมถึง AI ตามตรรกะ (LISP) และวิทยาการหุ่นยนต์
  • สัมภาษณ์Richard P. Gabriel (พอ ดคาสต์)
ทรัพยากร