common-lisp ट्यूटोरियल
शुरुआत आम-लिस्प से हुई

algorithm C Language C++ clojure Haskell Language Java Language GNU/Linux opencv Python Language vim
खोज…


टिप्पणियों

यह कॉमन लिस्प में एक साधारण हैलो वर्ल्ड फंक्शन है। उदाहरण पाठ को प्रिंट करेंगे Hello, World! (मानक संख्या के बिना उद्धरण चिह्नों के बाद)

आम लिस्प एक प्रोग्रामिंग भाषा है जो बड़े पैमाने पर इंटरएक्टिव रूप से एक इंटरफेस के रूप में उपयोग की जाती है जिसे आरईपीएल के रूप में जाना जाता है। REPL (रीड एवल प्रिंट लूप) एक को कोड टाइप करने की अनुमति देता है, क्या उसने इसका मूल्यांकन (रन) किया है और तुरंत परिणाम देखें। REPL के लिए संकेत (जिस बिंदु पर एक प्रकार का कोड चलाया जाना है) CL-USER> द्वारा इंगित किया गया है। कभी-कभी CL-USER अलावा कुछ और > से पहले दिखाई देगा, लेकिन यह अभी भी एक REPL है।

बाद शीघ्र कुछ कोड, आमतौर पर या तो एक शब्द (यानी एक चर नाम) या एक फार्म (बीच संलग्न शब्द / रूपों की एक सूची आता है ( और ) (यानी एक समारोह कॉल या घोषणा, आदि))। अगली पंक्ति में कोई भी आउटपुट होगा जो प्रोग्राम प्रिंट करता है (या यदि प्रोग्राम कुछ भी प्रिंट नहीं करता है) और तब अभिव्यक्ति का मूल्यांकन करके वापस आए मान। आम तौर पर एक अभिव्यक्ति एक मान लौटाती है, लेकिन अगर यह कई मान लौटाता है तो वे प्रति पंक्ति एक बार दिखाई देते हैं।

संस्करण

संस्करण रिलीज़ की तारीख
आम लिस्प 1984/01/01
ANSI आम लिस्प 1994/01/01

नमस्ते दुनिया

इस प्रकार आम लिस्प के साथ एक REPL सत्र का एक अंश है जिसमें "हैलो, वर्ल्ड!" फ़ंक्शन को परिभाषित और निष्पादित किया जाता है। REPL के अधिक गहन वर्णन के लिए इस पृष्ठ के निचले भाग पर टिप्पणी देखें। 

CL-USER> (defun hello ()
           (format t "Hello, World!~%"))
HELLO
CL-USER> (hello)
Hello, World!
NIL
CL-USER>

यह hello नाम के शून्य तर्कों के "फ़ंक्शन" को परिभाषित करता है, जो स्ट्रिंग "Hello, World!" लिखेगा। मानक आउटपुट में एक नई पंक्ति के बाद, और वापसी NIL ।

एक फ़ंक्शन को परिभाषित करने के लिए हम लिखते हैं 

(defun name (parameters...)
  code...)

इस मामले में फ़ंक्शन को hello कहा जाता है, कोई पैरामीटर नहीं लेता है और जो कोड चलता है वह एक फ़ंक्शन कॉल करना है। लिस्फ़ फ़ंक्शन से लौटाया गया मान, जो भी hello रिटर्न रन करने के लिए फ़ंक्शन का अंतिम बिट कोड है (format t "Hello, World!~%") रिटर्न।

किसी फ़ंक्शन को कॉल करने के लिए एक लिखते हैं (function-name arguments...) जहां function-name फ़ंक्शन और arguments... का function-name है arguments... कॉल करने के लिए तर्कों की (स्थान-पृथक) सूची है। कुछ विशेष मामले हैं जो फ़ंक्शन कॉल की तरह दिखते हैं, लेकिन उदाहरण के लिए, उपरोक्त कोड में कोई defun फ़ंक्शन नहीं है जिसे कॉल किया जाता है, यह विशेष रूप से व्यवहार किया जाता है और इसके बजाय फ़ंक्शन को परिभाषित करता है।

REPL के दूसरे प्रॉम्प्ट पर, हमने hello फंक्शन को परिभाषित करने के बाद, हम इसे (hello) लिखकर बिना किसी पैरामीटर के कहते हैं। यह बदले में format फ़ंक्शन को पैरामीटर t और "Hello, World!~%" साथ कॉल करेगा। format फ़ंक्शन तर्कों के आधार पर स्वरूपित आउटपुट का उत्पादन करता है जो इसे दिया जाता है (सी में printf एक उन्नत संस्करण की तरह)। पहला तर्क यह बताता है कि t -अर्थ स्टैंडर्ड-आउटपुट के साथ आउटपुट कहाँ करना है। दूसरा तर्क इसे बताता है कि क्या प्रिंट करना है (और किसी भी अतिरिक्त मापदंडों की व्याख्या कैसे करें)। निर्देश (दूसरे तर्क में विशेष कोड) ~% एक नई रेखा प्रिंट करने के लिए प्रारूप बताता है (यानी UNIX पर यह \n लिख सकता है और विंडोज़ \r\n )। प्रारूप आमतौर पर NIL (अन्य भाषाओं में NULL तरह एक सा) देता है।

दूसरे प्रॉम्प्ट के बाद हम देखते हैं कि Hello, World प्रिंट किया गया है और अगली पंक्ति में कि लौटाया गया मूल्य NIL ।

नमस्कार, नाम

यह थोड़ा और उन्नत उदाहरण है जो आम लिस्प की कुछ और विशेषताओं को दर्शाता है। हम एक सरल Hello, World! साथ शुरू करते हैं Hello, World! REPL में कुछ संवादात्मक विकास का कार्य और प्रदर्शन। ध्यान दें कि अर्धविराम से कोई भी पाठ ; , शेष पंक्ति के लिए एक टिप्पणी है। 

CL-USER> (defun hello ()
       (format t "Hello, World!~%")) ;We start as before
HELLO
CL-USER> (hello)
Hello, World!
NIL
CL-USER> (defun hello-name (name) ;A function to say hello to anyone
       (format t "Hello, ~a~%" name)) ;~a prints the next argument to format
HELLO-NAME
CL-USER> (hello-name "Jack")
Hello, Jack
NIL
CL-USER> (hello-name "jack") ;doesn't capitalise names
Hello, jack
NIL
CL-USER> (defun hello-name (name) ;format has a feature to convert to title case
       (format t "Hello, ~:(~a~)~%" name)) ;anything between ~:( and ~) gets it
WARNING: redefining COMMON-LISP-USER::HELLO-NAME in DEFUN
HELLO-NAME
CL-USER> (hello-name "jack")
Hello, Jack
NIL
CL-USER> (defun hello-name (name)
       (format t "Hello, ~:(~a~)!~%" name))
WARNING: redefining COMMON-LISP-USER::HELLO-NAME in DEFUN
HELLO-NAME
CL-USER> (hello-name "jack") ;now this works
Hello, Jack!
NIL
CL-USER> (defun hello (&optional (name "world")) ;we can take an optional argument
       (hello-name name)) ;name defaults to "world"
WARNING: redefining COMMON-LISP-USER::HELLO in DEFUN
HELLO
CL-USER> (hello)
Hello, World!
NIL
CL-USER> (hello "jack")
Hello, Jack!
NIL
CL-USER> (hello "john doe") ;note that this capitalises both names
Hello, John Doe!
NIL
CL-USER> (defun hello-person (name &key (number))
       (format t "Hello, ~a ~r" name number)) ;~r prints a number in English
HELLO-PERSON
CL-USER> (hello-person "Louis" :number 16) ;this doesn't quite work
Hello, Louis sixteen
NIL
CL-USER> (defun hello-person (name &key (number))
       (format t "Hello, ~:(~a ~:r~)!" name number)) ;~:r prints an ordinal
WARNING: redefining COMMON-LISP-USER::HELLO-PERSON in DEFUN
HELLO-PERSON
CL-USER> (hello-person "Louis" :number 16)
Hello, Louis Sixteenth!
NIL
CL-USER> (defun hello-person (name &key (number))
       (format t "Hello, ~:(~a ~@r~)!" name number)) ;~@r prints Roman numerals
WARNING: redefining COMMON-LISP-USER::HELLO-PERSON in DEFUN
HELLO-PERSON
CL-USER> (hello-person "Louis" :number 16)
Hello, Louis Xvi!
NIL
CL-USER> (defun hello-person (name &key (number)) ;capitalisation was wrong
       (format t "Hello, ~:(~a~) ~:@r!" name number))
WARNING: redefining COMMON-LISP-USER::HELLO-PERSON in DEFUN
HELLO-PERSON
CL-USER> (hello-person "Louis" :number 16) ;thats better
Hello, Louis XVI!
NIL
CL-USER> (hello-person "Louis") ;we get an error because NIL is not a number
Hello, Louis ; Evaluation aborted on #<SB-FORMAT:FORMAT-ERROR {1006641AB3}>.
CL-USER> (defun say-person (name &key (number 1 number-p)
                                      (title nil) (roman-number t))
       (let ((number (if number-p
                 (typecase number
                   (integer
                (format nil (if roman-number " ~:@r" " ~:(~:r~)") number))
                   (otherwise
                (format nil " ~:(~a~)" number)))
                 "")) ; here we define a variable called number
         (title (if title 
                (format nil "~:(~a~) " title)
                ""))) ; and here one called title
         (format nil "~a~:(~a~)~a" title name number))) ;we use them here

SAY-PERSON
CL-USER> (say-person "John") ;some examples
"John"
CL-USER> (say-person "john doe")
"John Doe"
CL-USER> (say-person "john doe" :number "JR")
"John Doe Jr"
CL-USER> (say-person "john doe" :number "Junior")
"John Doe Junior"
CL-USER> (say-person "john doe" :number 1)
"John Doe I"
CL-USER> (say-person "john doe" :number 1 :roman-number nil) ;this is wrong
"John Doe First"
CL-USER> (defun say-person (name &key (number 1 number-p)
                                      (title nil) (roman-number t))
       (let ((number (if number-p
                 (typecase number
                   (integer
                (format nil (if roman-number " ~:@r" " the ~:(~:r~)") number))
                   (otherwise
                (format nil " ~:(~a~)" number)))
                 ""))
         (title (if title 
                (format nil "~:(~a~) " title)
                "")))
         (format nil "~a~:(~a~)~a" title name number)))
WARNING: redefining COMMON-LISP-USER::SAY-PERSON in DEFUN
SAY-PERSON
CL-USER> (say-person "john doe" :number 1 :roman-number nil) ;thats better
"John Doe the First"
CL-USER> (say-person "louis" :title "king" :number 16 :roman-number nil)
"King Louis the Sixteenth"
CL-USER> (say-person "louis" :title "king" :number 16 :roman-number t)
"King Louis XVI"
CL-USER> (defun hello (&optional (name "World") &rest arguments) ;now we will just
       (apply #'hello-name name arguments)) ;pass all arguments to hello-name
WARNING: redefining COMMON-LISP-USER::HELLO in DEFUN
HELLO
CL-USER> (defun hello-name (name &rest arguments) ;which will now just use
       (format t "Hello, ~a!" (apply #'say-person name arguments))) ;say-person
WARNING: redefining COMMON-LISP-USER::HELLO-NAME in DEFUN
HELLO-NAME
CL-USER> (hello "louis" :title "king" :number 16) ;this works now
Hello, King Louis XVI!
NIL
CL-USER>

यह कॉमन लिस्प के format फ़ंक्शन की कुछ उन्नत सुविधाओं के साथ-साथ वैकल्पिक मापदंडों और कीवर्ड तर्क (जैसे :number ) जैसी कुछ विशेषताओं पर प्रकाश डालता है। यह आम लिस्प में एक REPL में इंटरैक्टिव विकास का एक उदाहरण देता है।

REPL में सरल हैलो वर्ल्ड कार्यक्रम

आम लिस्प REPL एक संवादात्मक वातावरण है। प्रॉम्प्ट के मूल्यांकन के बाद लिखा गया प्रत्येक फॉर्म, और मूल्यांकन के परिणाम के बाद उसका मूल्य मुद्रित किया जाता है। तो सबसे सरल संभव "नमस्ते, विश्व!" आम लिस्प में कार्यक्रम है: 

CL-USER> "Hello, World!"
"Hello, World!"
CL-USER>

यहां क्या होता है कि REPL को इनपुट में एक स्ट्रिंग कॉस्टेंट दिया जाता है, इसका मूल्यांकन किया जाता है और परिणाम प्रिंट किया जाता है। इस उदाहरण से जो देखा जा सकता है, वह यह है कि तार, संख्या की तरह, विशेष प्रतीक जैसे NIL और T और कुछ अन्य शाब्दिक, स्व-मूल्यांकन के रूप हैं: यानी वे स्वयं का मूल्यांकन करते हैं।

मूल भाव

आइए REPL में कुछ मूल अभिव्यक्ति का प्रयास करें: 

CL-USER> (+ 1 2 3)
6
CL-USER> (- 3 1 1)
1
CL-USER> (- 3)
-3
CL-USER> (+ 5.3 (- 3 2) (* 2 2))
10.3
CL-USER> (concatenate 'string "Hello, " "World!")
"Hello, World!"
CL-USER>

एक कॉमन लिस्प कार्यक्रम के मूल निर्माण खंड रूप है। इन उदाहरणों में हमारे पास फ़ंक्शंस फॉर्म हैं , जो कि अभिव्यक्ति है, सूची के रूप में लिखा गया है, जिसमें पहला तत्व एक ऑपरेटर (या फ़ंक्शन) है और बाकी तत्व ऑपरेंड हैं (इसे "उपसर्ग संकेतन", या "पोलिश संकेतन" कहा जाता है। ")। REPL में प्रपत्र लिखने से उनके मूल्यांकन का कारण बनता है। उदाहरणों में आप सरल भाव देख सकते हैं जिनके तर्क निरंतर संख्याएं, तार और प्रतीक हैं ( 'string के मामले में, जो एक प्रकार का नाम है)। आप यह भी देख सकते हैं कि अंकगणित ऑपरेटर किसी भी तरह के तर्क ले सकते हैं।

यह ध्यान रखना महत्वपूर्ण है कि कोष्ठक वाक्यविन्यास का एक अभिन्न अंग है, और अन्य प्रोग्रामिंग भाषाओं की तरह इसका स्वतंत्र रूप से उपयोग नहीं किया जा सकता है। उदाहरण के लिए निम्नलिखित एक त्रुटि है: 

(+ 5 ((+ 2 4)))
> Error: Car of ((+ 2 4)) is not a function name or lambda-expression. ...

आम लिस्प रूपों में भी डेटा, प्रतीक, मैक्रो फॉर्म, विशेष रूप और लैम्ब्डा रूप हो सकते हैं। उन्हें मूल्यांकन किए जाने के लिए लिखा जा सकता है, शून्य, एक या अधिक मान लौटाया जा सकता है, या किसी मैक्रो को इनपुट में दिया जा सकता है, जो उन्हें अन्य रूपों में रूपांतरित करता है।

पूर्णांकों की सूची का योग

(defun sum-list-integers (list)
    (reduce '+ list))

; 10
(sum-list-integers '(1 2 3 4))

; 55
(sum-list-integers '(1 2 3 4 5 6 7 8 9 10))

लैम्ब्डा एक्सप्रेशंस और बेनामी फ़ंक्शंस

एक अनाम फ़ंक्शन को बिना नाम के एक लैम्ब्डा एक्सप्रेशन के माध्यम से परिभाषित किया जा सकता है। कार्यों के इन प्रकार को परिभाषित करने के लिए, कीवर्ड lambda कीवर्ड की जगह प्रयोग किया जाता है defun । निम्नलिखित पंक्तियाँ सभी समतुल्य हैं और उन अनाम कार्यों को परिभाषित करती हैं जो दो संख्याओं के योग का उत्पादन करते हैं: 

(lambda (x y) (+ x y))
(function (lambda (x y) (+ x y)))
#'(lambda (x y) (+ x y))

लैंबडा फॉर्म्स बनाते समय उनकी उपयोगिता ध्यान देने योग्य होती है, यानी एक ऐसा फॉर्म जो एक ऐसी सूची है जिसमें पहला तत्व लैम्ब्डा एक्सप्रेशन है और बाकी एलिमेंट्स गुमनाम फंक्शन की दलीलें हैं। उदाहरण ( ऑनलाइन निष्पादन ): 

(print ((lambda (x y) (+ x y)) 1 2)) ; >> 3

(print (mapcar (lambda (x y) (+ x y)) '(1 2 3) '(2 -5 0))) ; >> (3 -3 3)

सामान्य लिस्प लर्निंग संसाधन

ऑनलाइन किताबें

ये ऐसी पुस्तकें हैं जो ऑनलाइन मुफ़्त में उपलब्ध हैं।

ऑनलाइन सन्दर्भ

ऑफ़लाइन पुस्तकें

ये वे पुस्तकें हैं जिनकी आपको लाइब्रेरी से खरीदने या उधार देने की संभावना होगी।

ऑनलाइन समुदाय

पुस्तकालय

  • क्विक लिस्प कॉमन लिस्प का पुस्तकालय प्रबंधक है, और समर्थित पुस्तकालयों की एक लंबी सूची है ।
  • Quickdocs कई सीएल पुस्तकालयों के लिए पुस्तकालय प्रलेखन का आयोजन करता है।
  • विस्मयकारी सीएल श्रेणी के आधार पर छांटे गए पुस्तकालयों, रूपरेखाओं और अन्य चमकदार सामानों की एक समुदाय-संचालित क्यूरेटेड सूची है।

पूर्व-पैक लिस्प वातावरण

ये लिस्प संपादन वातावरण हैं जिन्हें स्थापित करना आसान है और इसके साथ आरंभ करें क्योंकि आपको जो कुछ भी चाहिए वह पूर्व-पैक और पूर्व-कॉन्फ़िगर है।

  • पोर्टक्यूल एक पोर्टेबल और मल्टीप्लाकेट कॉमन लिस्प वातावरण है। यह Slime, SBCL (एक लोकप्रिय कॉमन लिस्प कार्यान्वयन), क्विकलिस्प और गिट के साथ थोड़ा अनुकूलित Emacs को शिप करता है। स्थापना की आवश्यकता नहीं है, इसलिए यह बहुत जल्दी और आसान तरीका है।
  • Lispbox एक IDE (Emacs + SLIME ), कॉमन लिस्प वातावरण (Clozure Common Lisp) और लाइब्रेरी मैनेजर (Quicklisp) है, जो Windows, Mac OSX और Linux के लिए अभिलेखागार के रूप में पूर्व-पैक है। प्रैक्टिकल कॉमन लिस्प पुस्तक में अनुशंसित "लिस्प इन ए बॉक्स" के वंशज।
  • पूर्व-पैक नहीं किया गया, लेकिन SLIME Emacs को एक आम लिस्प IDE में बदल देता है, और आपको आरंभ करने में मदद करने के लिए एक उपयोगकर्ता मैनुअल है। एक अलग कॉमन लिस्प कार्यान्वयन की आवश्यकता है।

आम लिस्प कार्यान्वयन

यह खंड कुछ सामान्य सीएल कार्यान्वयन और उनके मैनुअल को सूचीबद्ध करता है। जब तक अन्यथा उल्लेख नहीं किया जाता है, ये मुफ्त सॉफ्टवेयर कार्यान्वयन हैं। फ्री सॉफ्टवेयर कॉमन लिस्प इम्प्लीमेंटेशन की क्लिकी सूची और विकिपीडिया की कमर्शियल कॉमन लिस्प इम्प्लीमेंटेशन की सूची भी देखें।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow