Homoiconic Python भाषा

 (aljamal.substack.com)
2 पॉइंट द्वारा GN⁺ 2024-05-13 | 1 टिप्पणियां | WhatsApp पर शेयर करें

McCarthy के "Lisp in Lisp" को Python में लागू करना

  • 1960 के शुरुआती दशक में John McCarthy द्वारा विकसित Lisp में homoiconicity की विशेषता थी, इसलिए code और data एक-दूसरे के साथ अदल-बदल किए जा सकते हैं

    • Lisp में code और data की सीमा धुंधली हो जाती है
    • इसकी वजह से Lisp स्वाभाविक रूप से खुद को व्यक्त कर सकता है

  • Lisp 1.5 manual के पेज 13 के निचले हिस्से में दिया गया आधे पेज का code, खुद Lisp ही था

    • Alan Kay ने इसे "software की Maxwell equations" कहा था
    • programming की पूरी दुनिया सिर्फ कुछ पंक्तियों के code में संकुचित है

  • इसे समझने के लिए Python का उपयोग करके "Lisp in Lisp" code को फिर से लागू करना एक अच्छा तरीका है

    • अधिकांश programmer Lisp syntax से परिचित नहीं होंगे, लेकिन Python syntax से परिचित होंगे
    • लक्ष्य है Lisp code की मूल भावना को जितना संभव हो बनाए रखते हुए उसे Python में फिर से लिखना

Lisp के M-expression और S-expression

  • मूल रूप से Lisp में syntax के दो flavors थे

    • M-expression (meta expression): code flavor
    • S-expression (symbolic expression): data flavor
    • दोनों अर्थ की दृष्टि से समान हैं

  • "Lisp in Lisp" code, M-expression में लिखा गया था, और S-expression Lisp को लागू करता है

  • Lisp M-expression को Python code structure में बदलना, और S-expression को Python list के रूप में व्यक्त करना एक तरीका है

    • Lisp, List Processing का संक्षेप है, और इसमें केवल list नाम की एकल data structure का उपयोग होता है

पहला implementation

  • Python list की बुनियादी functions से Lisp के मूल operations लागू किए गए हैं

    • atom(x): जाँचता है कि x list है या नहीं
    • eq(x,y): जाँचता है कि x और y समान हैं या नहीं
    • car(x): list का पहला element लौटाता है
    • cdr(x): list का बाकी हिस्सा लौटाता है
    • cons(x,y): atom को list में जोड़ता है
    • append(x,y): दो lists को जोड़ता है

  • कुछ बुनियादी recursive तत्वों को नज़रअंदाज़ करके, Llama3-70b की मदद से "Lisp in Lisp" code के subset के लिए एक interpreter जल्दी लागू किया जा सकता है

दूसरा implementation

  • पहले implementation में lambda सुविधा नहीं है

    • Lisp में function को define और call करने का मुख्य तरीका lambda है
    • lambda के बिना recursion लागू नहीं किया जा सकता, और recursion के बिना यह Turing complete नहीं होता

  • lambda को लागू करने के लिए assoc(x,y) और pairlis(x,y) जैसे बुनियादी तत्वों की ज़रूरत होती है

    • assoc(x,y) association list का उपयोग करने वाला key/value dictionary lookup है
    • pairlis(x,y), Python के zip(x,y) जैसा है

  • Lisp में loop नहीं होता, इसलिए साधारण linear search के लिए भी recursion का उपयोग करना पड़ता था

    • लेकिन Python में इसे list comprehension का उपयोग करके सुंदर ढंग से बदला जा सकता है
    • evcon और evlis को भी इसी तरह loop में बदला जा सकता है

  • eval function मूल Lisp में दो arguments लेता है

    • पहला expression (s-exp), दूसरा environment है, जो key/value list होती है
    • environment, LAMBDA की variable binding को बनाए रखता है
    • इसमें dynamic scoping तकनीक का उपयोग होता है

GN⁺ की राय

  • Lisp की homoiconicity विशेषता को Python में अनुकरण करने का यह एक दिलचस्प प्रयास है। लेकिन Lisp की विशिष्ट विशेषताओं को पूरी तरह स्थानांतरित करने में सीमाएँ दिखती हैं। Lisp का आकर्षण अनुभव करना हो तो आखिरकार Lisp को ही सीखना सबसे अच्छा होगा.

  • lambda function और dynamic scoping जैसी Lisp की शक्तिशाली सुविधाओं को Python में लागू करना प्रभावशाली है। लेकिन इसे वास्तविक project में लागू करने के लिए अभी भी कई कमियाँ दिखती हैं। शिक्षा या research के उद्देश्य से यह मूल्यवान लग सकता है.

  • ऐसा प्रयास अपने आप में programming language के मूल स्वभाव पर गहराई से सोचने का अवसर दे सकता है। भाषा के syntax और implementation से आगे बढ़कर programming paradigm के दृष्टिकोण से देखने की नज़र मिल सकती है.

  • Lisp परिवार की भाषाएँ सीखना functional programming और meta programming के बारे में अंतर्दृष्टि पाने में मदद कर सकता है। Scheme, Clojure, Racket जैसी आधुनिक Lisp-परिवार की भाषाओं को देखना भी अच्छा रहेगा.

संबंधित पढ़ाई

1 टिप्पणियां

 
kayws426 2024-05-13

Python में एम्बेड किया गया Lisp का एक dialect
https://hylang.org/