ഹൈ - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

hy - hy ഡോക്യുമെന്റേഷൻ [ചിത്രം: ഹൈ] [ചിത്രം]

പരീക്ഷിക്കുക Hy https://try-hy.appspot.com

PYPI https://pypi.python.org/pypi/hy

ഉറവിടം https://github.com/hylang/hy

പട്ടിക ഹൈലാംഗ്-ചർച്ച

ഐആർസി #ഹൈ ഫ്രീനോഡിൽ

പണിയുക പദവി
ട്രാവിസ് CI.അൺഇൻഡന്റ്

പൈത്തണിൽ ഉൾച്ചേർത്ത ലിസ്‌പിന്റെ അതിമനോഹരമായ ഭാഷയാണ് ഹൈ.

Hy അതിന്റെ ലിസ്‌പ് കോഡ് പൈത്തൺ അബ്‌സ്‌ട്രാക്റ്റ് സിന്റാക്‌സ് ട്രീ ആയി മാറ്റുന്നതിനാൽ, നിങ്ങൾക്കുണ്ട്
പൈത്തണിന്റെ മനോഹരമായ ലോകം മുഴുവൻ നിങ്ങളുടെ വിരൽത്തുമ്പിൽ, ലിസ്പ് രൂപത്തിൽ!

ഉള്ളടക്കം:

പെട്ടെന്നുള്ള തുടക്കം

[ചിത്രം: കാരെൻ റസ്റ്റാർഡിന്റെ കഡിൽസ്] [ചിത്രം]

(കഡിൽസിന് കാരെൻ റസ്താദിന് നന്ദി!)

എങ്ങനെ TO നേടുക HY റിയൽ വേഗതയേറിയ:

1. സൃഷ്ടിക്കുക വെർച്വൽ പൈത്തൺ പരിസ്ഥിതി.

2. നിങ്ങളുടെ വെർച്വൽ പൈത്തൺ എൻവയോൺമെന്റ് സജീവമാക്കുക.

3. ഇൻസ്റ്റോൾ hy നിന്ന് PYPI കൂടെ PIP ഇൻസ്റ്റാൾ ചെയ്യുക hy.

4. ഒരു REPL ആരംഭിക്കുക hy.

5. REPL-ൽ സ്റ്റഫ് ടൈപ്പ് ചെയ്യുക:

=> ("ഹായ്!" അച്ചടിക്കുക)
ഹായ്!
=> (defn salutationsnm [name] (+ "Hy " name "!")))
=> ("നിങ്ങളുടെ പേര്" അഭിവാദ്യങ്ങൾ)
നിങ്ങളുടെ പേര്!

തുടങ്ങിയവ

6. നിങ്ങൾ പൂർത്തിയാക്കുമ്പോൾ CTRL-D അമർത്തുക.

ദൈവമേ! അത് കൊള്ളാം! I ആഗ്രഹിക്കുന്നു ലേക്ക് എഴുതുക a Hy പ്രോഗ്രാം.

7. ഒരു എലൈറ്റ് പ്രോഗ്രാമിംഗ് എഡിറ്റർ തുറന്ന് ടൈപ്പ് ചെയ്യുക:

("ഞാൻ പൈത്തൺ വാക്യഘടനയിൽ കോഡ് ചെയ്യാൻ പോകുകയായിരുന്നു, പക്ഷേ എനിക്ക് ഹൈ ലഭിച്ചു.")

8. ഇതായി സംരക്ഷിക്കുക ഗംഭീരം.hy.

9. നിങ്ങളുടെ ആദ്യത്തെ ഹൈ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക:

hy awesome.hy

10.
ഹൈപ്പർവെൻറിലേറ്റ് ചെയ്യാതിരിക്കാൻ ആഴത്തിലുള്ള ശ്വാസം എടുക്കുക.

11.
വില്ലനായി പുഞ്ചിരിക്കുക, നിങ്ങളുടെ ഹൈഡ്‌വേയിലേക്ക് ഒളിച്ചോടുക, പറഞ്ഞറിയിക്കാൻ കഴിയാത്ത കാര്യങ്ങൾ ചെയ്യുക.

TUTORIAL

ഹൈ ട്യൂട്ടോറിയലിലേക്ക് സ്വാഗതം!

ചുരുക്കത്തിൽ, ഹൈ ഒരു ലിസ്‌പ് ഭാഷയാണ്, എന്നാൽ അതിന്റെ ഘടനയെ പൈത്തണാക്കി മാറ്റുന്ന ഒന്നാണ് ...
അക്ഷരാർത്ഥത്തിൽ പൈത്തണിന്റെ അമൂർത്തമായ വാക്യഘടനയിലേക്കുള്ള പരിവർത്തനം! (അല്ലെങ്കിൽ കൂടുതൽ അസംസ്‌കൃതത്തിൽ ഇടുക
നിബന്ധനകൾ, Hy എന്നത് ഒരു പൈത്തണിലെ ലിസ്പ്-സ്റ്റിക്ക് ആണ്!)

ഇത് വളരെ രസകരമാണ്, കാരണം Hy എന്നത് നിരവധി കാര്യങ്ങൾ ആണ്:

· വളരെ പൈത്തോണിക് അനുഭവപ്പെടുന്ന ഒരു ലിസ്പ്

ലിസ്‌പേഴ്‌സിന്, ലിസ്‌പിന്റെ ഭ്രാന്തൻ ശക്തികൾ ഉപയോഗിക്കാനുള്ള മികച്ച മാർഗം, എന്നാൽ പൈത്തണിന്റെ വിശാലമായ ലോകത്ത്
ലൈബ്രറികൾ (എന്തുകൊണ്ട് അതെ, നിങ്ങൾക്ക് ഇപ്പോൾ ലിസ്‌പിൽ ഒരു ജാങ്കോ ആപ്ലിക്കേഷൻ എഴുതാം!)

· പൈത്തണിസ്റ്റാസിന്, പൈത്തണിന്റെ സുഖസൗകര്യങ്ങളിൽ നിന്ന് ലിസ്‌പ് പര്യവേക്ഷണം ചെയ്യാൻ ആരംഭിക്കുന്നതിനുള്ള മികച്ച മാർഗം!

· എല്ലാവർക്കുമായി: ധാരാളം വൃത്തിയുള്ള ആശയങ്ങളുള്ള മനോഹരമായ ഭാഷ!

അടിസ്ഥാനപരമായ ആമുഖം ലേക്ക് കൊഞ്ഞ വേണ്ടി പൈത്തണിസ്റ്റാസ്
ശരി, നിങ്ങൾ മുമ്പ് ലിസ്പ് ഉപയോഗിച്ചിട്ടില്ലായിരിക്കാം, പക്ഷേ നിങ്ങൾ പൈത്തൺ ഉപയോഗിച്ചിട്ടുണ്ട്!

ഹൈയിലെ ഒരു "ഹലോ വേൾഡ്" പ്രോഗ്രാം യഥാർത്ഥത്തിൽ വളരെ ലളിതമാണ്. നമുക്ക് ശ്രമിക്കാം:

("ഹലോ വേൾഡ്" അച്ചടിക്കുക)

കണ്ടോ? എളുപ്പം! നിങ്ങൾ ഊഹിച്ചതുപോലെ, ഇത് പൈത്തൺ പതിപ്പിന് സമാനമാണ്:

"ഹലോ വേൾഡ്" എന്ന് അച്ചടിക്കുക

ചില സൂപ്പർ സിമ്പിൾ ഗണിതം കൂട്ടിച്ചേർക്കുന്നതിന്, നമുക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാം:

(+ 1 3)

ഇത് 4 തിരികെ നൽകും, ഇതിന് തുല്യമായിരിക്കും:

1 + 3

നിങ്ങൾ ശ്രദ്ധിക്കുന്നത്, ലിസ്റ്റിലെ ആദ്യ ഇനം വിളിക്കപ്പെടുന്ന ഫംഗ്‌ഷനാണ്
ബാക്കിയുള്ള ആർഗ്യുമെന്റുകൾ പാസാക്കുന്ന ആർഗ്യുമെന്റുകളാണ്. വാസ്തവത്തിൽ, ഹൈയിൽ (മിക്കവാറും പോലെ
ലിസ്പ്സ്) നമുക്ക് പ്ലസ് ഓപ്പറേറ്റർക്ക് ഒന്നിലധികം ആർഗ്യുമെന്റുകൾ നൽകാം:

(+ 1 3 55)

അത് 59 തിരികെ നൽകും.

ലിസ്‌പിനെക്കുറിച്ച് നിങ്ങൾ മുമ്പ് കേട്ടിട്ടുണ്ടാകാം, പക്ഷേ അതിനെക്കുറിച്ച് കൂടുതൽ അറിയില്ല. ലിസ്പ് നിങ്ങളെപ്പോലെ കഠിനമല്ല
വിചാരിച്ചേക്കാം, ഹൈ പൈത്തണിൽ നിന്ന് അവകാശമാക്കുന്നു, അതിനാൽ ലിസ്‌പ് പഠിക്കാൻ തുടങ്ങുന്നതിനുള്ള മികച്ച മാർഗമാണ് ഹൈ.
ലിസ്‌പിനെക്കുറിച്ച് വ്യക്തമായ പ്രധാന കാര്യം, ധാരാളം പരാൻതീസിസുകൾ ഉണ്ട് എന്നതാണ്. ഇത് ഒരുപക്ഷേ
ആദ്യം ആശയക്കുഴപ്പം തോന്നുന്നു, പക്ഷേ അത് അത്ര ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല. ചില ലളിതമായ ഗണിതം നോക്കാം
നമുക്ക് ഹൈ ഇന്റർപ്രെറ്ററിലേക്ക് പ്രവേശിക്കാൻ കഴിയുന്ന ഒരു കൂട്ടം പരാൻതീസിസിൽ പൊതിഞ്ഞ്:

(setv ഫലം (- (/ (+ 1 3 88) 2) 8))

ഇത് തിരികെ നൽകും 38. എന്നാൽ എന്തുകൊണ്ട്? ശരി, നമുക്ക് തുല്യമായ പദപ്രയോഗം നോക്കാം
പെരുമ്പാമ്പ്:

ഫലം = ((1 + 3 + 88) / 2) - 8

പൈത്തണിൽ മേൽപ്പറഞ്ഞവ എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് മനസിലാക്കാൻ നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, തീർച്ചയായും നിങ്ങൾക്ക് ഇഷ്ടപ്പെടും
ഓരോ ആന്തരിക പരാന്തീസിസും പരിഹരിച്ചുകൊണ്ട് ഫലങ്ങൾ കണ്ടെത്തുക. അതേ അടിസ്ഥാന ആശയം തന്നെയാണ്
ഹൈ. പൈത്തണിൽ ആദ്യം ഈ വ്യായാമം പരീക്ഷിക്കാം:

ഫലം = ((1 + 3 + 88) / 2) - 8
# ലളിതമാക്കി...
ഫലം = (92/2) - 8
# ലളിതമാക്കി...
ഫലം = 46 - 8
# ലളിതമാക്കി...
ഫലം = 38

ഇനി നമുക്ക് Hy യിൽ അതേ കാര്യം പരീക്ഷിക്കാം:

(setv ഫലം (- (/ (+ 1 3 88) 2) 8))
; ലളിതമാക്കി...
(setv ഫലം (- (/ 92 2) 8))
; ലളിതമാക്കി...
(setv ഫലം (- 46 8))
; ലളിതമാക്കി...
(സെറ്റീവ് ഫലം 38)

നിങ്ങൾ ഊഹിച്ചതുപോലെ, ഈ അവസാന പദപ്രയോഗം setv വേരിയബിൾ അസൈൻ ചെയ്യുക എന്നാണ് അർത്ഥമാക്കുന്നത്
"ഫലം" 38 ലേക്ക്.

കണ്ടോ? വളരെ കഠിനമല്ല!

ഇതാണ് ലിസ്പിന്റെ അടിസ്ഥാന തത്വം. ലിസ്പ് എന്നാൽ "ലിസ്റ്റ് പ്രോസസ്സിംഗ്"; ഇതിനർത്ഥം
പ്രോഗ്രാമിന്റെ ഘടന യഥാർത്ഥത്തിൽ ലിസ്റ്റുകളുടെ ലിസ്റ്റുകളാണ്. (നിങ്ങൾക്ക് പൈത്തണിനെ പരിചയമുണ്ടെങ്കിൽ
ലിസ്‌റ്റുകൾ, മുകളിലുള്ള അതേ ഘടന സങ്കൽപ്പിക്കുക, പകരം ചതുര ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച്, ഏതെങ്കിലും
മുകളിലെ ഘടന ഒരു പ്രോഗ്രാമായും ഡാറ്റാസ്ട്രക്ചറായും നിങ്ങൾക്ക് കാണാൻ കഴിയും.) ഇതാണ്
കൂടുതൽ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് മനസ്സിലാക്കാൻ എളുപ്പമാണ്, അതിനാൽ നമുക്ക് ഒരു ലളിതമായ പൈത്തൺ പ്രോഗ്രാം എഴുതാം, അത് പരീക്ഷിക്കുക,
തുടർന്ന് തുല്യമായ Hy പ്രോഗ്രാം കാണിക്കുക:

def simple_conversation():
പ്രിന്റ് "ഹലോ! എനിക്ക് നിങ്ങളെ അറിയാൻ ആഗ്രഹമുണ്ട്. നിങ്ങളെക്കുറിച്ച് എന്നോട് പറയൂ!"
പേര് = raw_input("നിങ്ങളുടെ പേരെന്താണ്? ")
പ്രായം = raw_input("നിങ്ങളുടെ പ്രായം എന്താണ്? ")
പ്രിന്റ് "ഹലോ " + പേര് + "! നിങ്ങൾക്ക് " + വയസ്സ് + " വയസ്സായി എന്ന് ഞാൻ കാണുന്നു."

ലളിതമായ_സംഭാഷണം()

ഞങ്ങൾ ഈ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് ഇങ്ങനെ പോയേക്കാം:

ഹലോ! നിങ്ങളെ അറിയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. നിന്നേപ്പറ്റി പറയൂ!
എന്താണ് നിന്റെ പേര്? ഗാരി
എന്താണ് നിങ്ങളുടെ പ്രായം? 38
ഹലോ ഗാരി ! നിങ്ങൾക്ക് 38 വയസ്സായി ഞാൻ കാണുന്നു.

ഇപ്പോൾ നമുക്ക് തുല്യമായ Hy പ്രോഗ്രാം നോക്കാം:

(defn ലളിത-സംഭാഷണം []
("ഹലോ! നിങ്ങളെ അറിയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. നിങ്ങളെക്കുറിച്ച് എന്നോട് പറയൂ!")
(setv നാമം (റോ-ഇൻപുട്ട് "നിങ്ങളുടെ പേര് എന്താണ്?"))
(setv age (റോ-ഇൻപുട്ട് "നിങ്ങളുടെ വയസ്സ് എന്താണ്?"))
(+ "ഹലോ " പേര് "! ഞാൻ നിങ്ങളെ കാണുന്നു
പ്രായം "വയസ്സ്")))

(ലളിതമായ സംഭാഷണം)

മുകളിലുള്ള പ്രോഗ്രാം നോക്കുകയാണെങ്കിൽ, ഓരോന്നിലും ആദ്യ ഘടകം നിങ്ങൾ ഓർക്കുന്നിടത്തോളം
പ്രോഗ്രാമിന്റെ ലിസ്‌റ്റ് എന്നത് ഫംഗ്‌ഷൻ (അല്ലെങ്കിൽ മാക്രോ... നമുക്ക് പിന്നീട് ലഭിക്കും) എന്ന് വിളിക്കപ്പെടുന്നു
ബാക്കിയുള്ളവ വാദങ്ങളാണെന്നും, ഇതെല്ലാം എന്താണ് അർത്ഥമാക്കുന്നത് എന്ന് മനസിലാക്കാൻ വളരെ എളുപ്പമാണ്.
(നിങ്ങളും ഊഹിച്ചതുപോലെ, defn രീതികൾ നിർവചിക്കുന്നതിനുള്ള ഹൈ രീതിയാണ്.)

എന്നിരുന്നാലും, നിരവധി പരാൻതീസിസുകൾ ഉള്ളതിനാൽ പലരും ആദ്യം ഇത് ആശയക്കുഴപ്പത്തിലാക്കുന്നു.
എന്നാൽ ഇത് എളുപ്പമാക്കാൻ സഹായിക്കുന്ന നിരവധി കാര്യങ്ങളുണ്ട്: ഇൻഡന്റേഷൻ ഭംഗിയായി സൂക്ഷിക്കുക
പരാൻതീസിസ് പൊരുത്തപ്പെടുന്ന ഒരു എഡിറ്റർ ഉപയോഗിക്കുക (ഓരോന്നും എന്താണെന്ന് മനസിലാക്കാൻ ഇത് നിങ്ങളെ സഹായിക്കും
പരാന്തീസിസ് ജോടിയാക്കുന്നു) കൂടാതെ കാര്യങ്ങൾ സുഖകരമാകാൻ തുടങ്ങും.

യഥാർത്ഥത്തിൽ വളരെ ലളിതമായ ഡാറ്റയായ ഒരു കോഡ് ഘടനയ്ക്ക് ചില ഗുണങ്ങളുണ്ട്
ലിസ്‌പിന്റെ കാതൽ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഘടന. ഒരു കാര്യം, നിങ്ങളുടെ പ്രോഗ്രാമുകൾ എന്നാണ്
പാഴ്‌സ് ചെയ്യാൻ എളുപ്പമാണ് കൂടാതെ പ്രോഗ്രാമിന്റെ മുഴുവൻ യഥാർത്ഥ ഘടനയും വളരെ വ്യക്തമായി തുറന്നുകാട്ടപ്പെടുന്നു
നിനക്ക്. (നിങ്ങൾ കാണുന്ന ഘടന പൈത്തണിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്ന ഒരു അധിക ഘട്ടമുണ്ട്
സ്വന്തം പ്രാതിനിധ്യങ്ങൾ ... Common Lisp അല്ലെങ്കിൽ Emacs Lisp പോലെയുള്ള "ശുദ്ധമായ" ലിസ്‌പുകളിൽ, ഡാറ്റ
നിങ്ങൾ കോഡിൽ കാണുന്ന ഘടനയും എക്സിക്യൂട്ട് ചെയ്യുന്ന ഡാറ്റ ഘടനയും വളരെ കൂടുതലാണ്
അക്ഷരാർത്ഥത്തിൽ അടുത്ത്.)

ഇതിന്റെ മറ്റൊരു സൂചനയാണ് മാക്രോസ്: ഒരു പ്രോഗ്രാമിന്റെ ഘടന ഒരു ലളിതമായ ഡാറ്റയാണെങ്കിൽ
ഘടന, അതായത് നിങ്ങൾക്ക് വളരെ എളുപ്പത്തിൽ കോഡ് എഴുതാൻ കഴിയുന്ന കോഡ് എഴുതാം, അതായത്
പൂർണ്ണമായും പുതിയ ഭാഷാ സവിശേഷതകൾ നടപ്പിലാക്കുന്നത് വളരെ വേഗത്തിലാണ്. Hy-ന് മുമ്പ്, ഇതായിരുന്നില്ല
പൈത്തൺ പ്രോഗ്രാമർമാർക്ക് വളരെ സാദ്ധ്യമാണ് ... ഇപ്പോൾ നിങ്ങൾക്കും മാക്രോകളുടെ അവിശ്വസനീയമായ ഉപയോഗം ഉപയോഗിക്കാം
ശക്തി (അവരെ കാൽനടയായി ലക്ഷ്യമിടാതിരിക്കാൻ ശ്രദ്ധിക്കുക)!

Hy is a ലിസ്പ്-ഫ്ലേവർ പൈത്തൺ
ഹൈ പൈത്തണിന്റെ സ്വന്തം അബ്‌സ്‌ട്രാക്റ്റ് സിന്റാക്‌സ് ട്രീയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, അതിനാൽ നിങ്ങൾ ഉടൻ തന്നെ എല്ലാം കണ്ടെത്താൻ തുടങ്ങും
പെരുമ്പാമ്പിന്റെ പരിചിതമായ ശക്തി നിങ്ങളുടെ വിരൽത്തുമ്പിലാണ്.

ഹൈയിലെ പൈത്തണിന്റെ ഡാറ്റ തരങ്ങളിലേക്കും സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിലേക്കും നിങ്ങൾക്ക് പൂർണ്ണ ആക്‌സസ് ഉണ്ട്. നമുക്ക് പരീക്ഷണം നടത്താം
ഹൈ ഇന്റർപ്രെറ്ററിൽ ഇതോടൊപ്പം:

=> [1 2 3]
[XXX, 1, 2]
=> {"നായ" "കുരയ്ക്കുക"
... "പൂച്ച" "മ്യാവൂ"}
...
{'നായ': 'കുരയ്ക്കുക', 'പൂച്ച': 'മിയാവ്'}
=> (, 1 2 3)
(1, 2, 3)

നിങ്ങൾക്ക് മറ്റ് ലിസ്‌പുകളുമായി പരിചയമുണ്ടെങ്കിൽ, ഹൈ കോമണിനെ പിന്തുണയ്ക്കുന്നത് നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടാകാം
ലിസ്പ് ഉദ്ധരണി രീതി:

=> '(1 2 3)
(1L 2L 3L)

എല്ലാ അന്തർനിർമ്മിത തരങ്ങളിലേക്കും നിങ്ങൾക്ക് ആക്‌സസ് ഉണ്ട്:

=> (.സ്ട്രിപ്പ് " fooooo ")
"fooooo"

എന്താണിത്? അതെ, ഇത് കൃത്യമായി സമാനമാണ്:

" fooooo ".സ്ട്രിപ്പ്()

അത് ശരിയാണ് --- ഡോട്ട് നൊട്ടേഷനോടുകൂടിയ ലിസ്പ്! നമുക്ക് ഈ സ്ട്രിംഗ് ഒരു വേരിയബിളായി നൽകിയിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ
ഇനിപ്പറയുന്നവ ചെയ്യാനും കഴിയും:

(ഈ സ്ട്രിംഗ് സജ്ജമാക്കുക " fooooo ")
(this-string.strip)

നിബന്ധനകളെക്കുറിച്ച്?:

(എന്തെങ്കിലും ശ്രമിച്ചാൽ)
("ഇത് ശരിയാണെങ്കിൽ" എന്ന് അച്ചടിക്കുക)
("ഇത് തെറ്റാണെങ്കിൽ" എന്ന് അച്ചടിക്കുക))

നിങ്ങൾക്ക് മുകളിൽ പറയാൻ കഴിയുന്നതുപോലെ, ആദ്യ വാദം if സത്യപരിശോധനയാണ്, രണ്ടാമത്തെ വാദം
ശരിയാണെങ്കിൽ ശരീരം, മൂന്നാമത്തെ വാദം (ഓപ്ഷണൽ!) തെറ്റാണെങ്കിൽ (അതായത്. മറ്റാരെങ്കിലും).

നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ വ്യവസ്ഥകൾ ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് ഇല്ലെന്ന് നിങ്ങൾ കണ്ടെത്തും എലിഫ്
ഹൈയിൽ ലഭ്യമാണ്. പകരം, നിങ്ങൾ വിളിക്കുന്ന എന്തെങ്കിലും ഉപയോഗിക്കണം അവസ്ഥ. പൈത്തണിൽ, നിങ്ങൾ ചെയ്തേക്കാം
അതുപോലത്തെ:

ചിലവർ = 33
somevar> 50 ആണെങ്കിൽ:
പ്രിന്റ് "ആ വേരിയബിൾ വളരെ വലുതാണ്!"
elif somevar < 10:
പ്രിന്റ് "ആ വേരിയബിൾ വളരെ ചെറുതാണ്!"
വേറെ:
പ്രിന്റ് ചെയ്യുക "ആ വേരിയബിൾ ശരിയാണ്!"

ഹൈയിൽ, നിങ്ങൾ ചെയ്യും:

(കോണ്ഡി
[(> ചിലത് 50)
("ആ വേരിയബിൾ വളരെ വലുതാണ്!")]
[(< ചിലത് 10)
("ആ വേരിയബിൾ വളരെ ചെറുതാണ്!")]
[ശരി
("ആ വേരിയബിൾ ശരിയാണ്!")])

നിങ്ങൾ ശ്രദ്ധിക്കുന്നത് അതാണ് അവസ്ഥ എക്സിക്യൂട്ട് ചെയ്ത ചില പ്രസ്താവനകൾക്കിടയിൽ സ്വിച്ച് ഓഫ് ചെയ്യുന്നു
ശരിയോ തെറ്റോ എന്ന് സോപാധികമായി പരിശോധിച്ചു, തുടർന്ന് അത് തിരിയുകയാണെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യാൻ ഒരു ബിറ്റ് കോഡ്
സത്യമാണ്. എന്നതും നിങ്ങൾ ശ്രദ്ധിക്കും മറ്റാരെങ്കിലും ലളിതമായി അവസാനം നടപ്പിലാക്കുന്നു
പരിശോധിക്കുന്നു യഥാർഥ -- അത് കാരണം യഥാർഥ എല്ലായ്‌പ്പോഴും സത്യമായിരിക്കും, അതിനാൽ ഞങ്ങൾ ഇത്രയും ദൂരം എത്തിയാൽ, ഞങ്ങൾ ചെയ്യും
എപ്പോഴും അത് പ്രവർത്തിപ്പിക്കുക!

നിങ്ങൾക്ക് ഇതുപോലുള്ള കോഡ് ഉണ്ടെങ്കിൽ അത് മുകളിൽ ശ്രദ്ധിച്ചേക്കാം:

(ചില വ്യവസ്ഥകളുണ്ടെങ്കിൽ
(ശരീരം-സത്യമെങ്കിൽ)
(ശരീരം-തെറ്റാണെങ്കിൽ))

എന്നാൽ കാത്തിരിക്കുക! ഒരാളുടെ ബോഡിയിൽ ഒന്നിലധികം പ്രസ്താവനകൾ നടപ്പിലാക്കണമെങ്കിൽ എന്തുചെയ്യും
ഇവ?

നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയും:

(എന്തെങ്കിലും ശ്രമിച്ചാൽ)
(ചെയ്യുക
("ഇത് ശരിയാണെങ്കിൽ" എന്ന് അച്ചടിക്കുക)
(അച്ചടിക്കുക "എന്തുകൊണ്ട് അല്ല, അത് എത്രത്തോളം ശരിയാണെന്ന് നമുക്ക് സംസാരിക്കാം!))
("ഇത് ഇപ്പോഴും വെറും തെറ്റാണ്" എന്ന് അച്ചടിക്കുക))

ഞങ്ങൾ ഉപയോഗിച്ചതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും do ഒന്നിലധികം പ്രസ്താവനകൾ പൊതിയാൻ. നിങ്ങൾക്ക് മറ്റുള്ളവരുമായി പരിചയമുണ്ടെങ്കിൽ
ലിസ്പ്സ്, ഇത് തുല്യമാണ് പ്രവചനം മറ്റെവിടെയെങ്കിലും.

കമന്റുകൾ അർദ്ധവിരാമങ്ങളിൽ ആരംഭിക്കുന്നു:

("ഇത് പ്രവർത്തിക്കും" എന്ന് അച്ചടിക്കുക)
; ("എന്നാൽ ഇത് ചെയ്യില്ല" എന്ന് അച്ചടിക്കുക)
(+ 1 2 3) ; ഞങ്ങൾ കൂട്ടിച്ചേർക്കൽ നടപ്പിലാക്കും, പക്ഷേ ഈ അഭിപ്രായമല്ല!

ലൂപ്പിംഗ് ബുദ്ധിമുട്ടുള്ളതല്ല, പക്ഷേ ഒരു പ്രത്യേക ഘടനയുണ്ട്. പൈത്തണിൽ, നമുക്ക് ചെയ്യാം:

ഞാൻ ഉള്ളതിന് ശ്രേണി(10):
പ്രിന്റ് "'i' ഇപ്പോൾ " + str(i) എന്നതിലാണ്

ഹൈയിലെ തത്തുല്യം ഇതായിരിക്കും:

(ഞാൻ (പരിധി 10)]
(അച്ചടിക്കൂ (+ "'i' ഇപ്പോൾ " (str i))))

നിങ്ങൾക്ക് വിവിധ പൈത്തൺ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യാനും ഉപയോഗിക്കാനും കഴിയും. ഉദാഹരണത്തിന്:

(ഇറക്കുമതി OS)

(എങ്കിൽ (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
("ഹേയ്, ആ പാത അവിടെ ഇല്ല!"))

പൈത്തണിന്റെ സന്ദർഭ മാനേജർമാർ (കൂടെ പ്രസ്താവനകൾ) ഇതുപോലെ ഉപയോഗിക്കുന്നു:

([[f (തുറക്കുക "/tmp/data.in")]]
(പ്രിന്റ് (.റീഡ് എഫ്)))

ഇതിന് തുല്യമാണ്:

f ആയി ഓപ്പൺ("/tmp/data.in") ഉപയോഗിച്ച്:
പ്രിന്റ് f.read()

അതെ, ഞങ്ങൾക്ക് ലിസ്റ്റ് മനസ്സിലാക്കലുകൾ ഉണ്ട്! പൈത്തണിൽ നിങ്ങൾക്ക് ചെയ്യാവുന്നതാണ്:

വിചിത്ര_ചതുരം = [
പൗവ്(സംഖ്യ, 2)
എന്നതിന് ശ്രേണി(100)
സംഖ്യ % 2 എങ്കിൽ == 1]

ഹൈയിൽ, നിങ്ങൾക്ക് ഇവ ചെയ്യാവുന്നതാണ്:

(setv odds-squared
(ലിസ്റ്റ്-കോം
(പൗ നമ്പർ 2)
(എണ്ണം (പരിധി 100))
(= (% സംഖ്യ 2) 1)))

; കൂടാതെ, ഒരു ക്ലോജൂർ പേജിൽ നിന്ന് ലജ്ജയില്ലാതെ മോഷ്ടിച്ച ഒരു ഉദാഹരണം:
; ഒരു ചെസ്സ്ബോർഡിന്റെ എല്ലാ ബ്ലോക്കുകളും നമുക്ക് പട്ടികപ്പെടുത്താം:

(ലിസ്റ്റ്-കോം
(, xy)
(x (പരിധി 8)
y "ABCDEFGH"))

; [(0, 'A'), (0, 'B'), (0, 'C'), (0, 'D'), (0, 'E'), (0, 'F'), ( 0, 'ജി'), (0, 'എച്ച്'),
; (1, 'എ'), (1, 'ബി'), (1, 'സി'), (1, 'ഡി'), (1, 'ഇ'), (1, 'എഫ്'), (1 , 'ജി'), (1, 'എച്ച്'),
; (2, 'എ'), (2, 'ബി'), (2, 'സി'), (2, 'ഡി'), (2, 'ഇ'), (2, 'എഫ്'), (2 , 'ജി'), (2, 'എച്ച്'),
; (3, 'എ'), (3, 'ബി'), (3, 'സി'), (3, 'ഡി'), (3, 'ഇ'), (3, 'എഫ്'), (3 , 'ജി'), (3, 'എച്ച്'),
; (4, 'എ'), (4, 'ബി'), (4, 'സി'), (4, 'ഡി'), (4, 'ഇ'), (4, 'എഫ്'), (4 , 'ജി'), (4, 'എച്ച്'),
; (5, 'എ'), (5, 'ബി'), (5, 'സി'), (5, 'ഡി'), (5, 'ഇ'), (5, 'എഫ്'), (5 , 'ജി'), (5, 'എച്ച്'),
; (6, 'എ'), (6, 'ബി'), (6, 'സി'), (6, 'ഡി'), (6, 'ഇ'), (6, 'എഫ്'), (6 , 'ജി'), (6, 'എച്ച്'),
; (7, 'എ'), (7, 'ബി'), (7, 'സി'), (7, 'ഡി'), (7, 'ഇ'), (7, 'എഫ്'), (7 , 'G'), (7, 'H')]

വിവിധ ഫാൻസി ആർഗ്യുമെന്റുകൾക്കും കീവേഡ് ആർഗ്യുമെന്റുകൾക്കും പൈത്തണിന് പിന്തുണയുണ്ട്. പൈത്തണിൽ നമുക്കായിരിക്കാം
കാണുക:

>>> def optional_arg(pos1, pos2, കീവേഡ്1=ഒന്നുമില്ല, കീവേഡ്2=42):
... മടങ്ങുക [pos1, pos2, കീവേഡ്1, കീവേഡ്2]
...
>>> optional_arg(1, 2)
[1, 2, ഒന്നുമില്ല, 42]
>>> optional_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> optional_arg(keyword1=1, pos2=2, pos1=3, keyword2=4)
[3, 2, 1, 4]

Hy യിലെ അതേ കാര്യം:

=> (defn optional-arg [pos1 pos2 &ഓപ്ഷണൽ കീവേഡ്1 [കീവേഡ്2 42]]
... [pos1 pos2 കീവേഡ്1 കീവേഡ്2])
=> (ഓപ്ഷണൽ-ആർഗ് 1 2)
[1 2 ഒന്നുമില്ല 42]
=> (ഓപ്ഷണൽ-ആർഗ് 1 2 3 4)
[1 2 3 4]

നിങ്ങൾ ഹൈ പാസ്റ്റ് 0.10.1-ന്റെ ഒരു പതിപ്പാണ് പ്രവർത്തിപ്പിക്കുന്നതെങ്കിൽ (ഉദാഹരണത്തിന്, ജിറ്റ് മാസ്റ്റർ), ഒരു നല്ല പുതിയതും ഉണ്ട്
കീവേഡ് ആർഗ്യുമെന്റ് വാക്യഘടന:

=> (ഓപ്ഷണൽ-ആർഗ്:കീവേഡ്1 1
... :pos2 2
... :pos1 3
... :കീവേഡ്2 4)
[3, 2, 1, 4]

അല്ലെങ്കിൽ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം പ്രയോഗിക്കുക. എന്നാൽ എന്താണ് പ്രയോഗിക്കുക?

കടന്നുപോകുന്നത് നിങ്ങൾക്ക് പരിചിതമാണോ? *ആർഗ്സ് ഒപ്പം **kwargs പൈത്തണിൽ?:

>>> args = [1 2]
>>> kwargs = {"keyword2": 3
... "കീവേഡ്1": 4}
>>> optional_arg(*args, **kwargs)

നമുക്ക് ഇത് പുനർനിർമ്മിക്കാം പ്രയോഗിക്കുക:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "കീവേഡ്1" 4})
=> (ഓപ്ഷണൽ-ആർഗ് ആർഗ്സ് ക്വാർഗ്സ് പ്രയോഗിക്കുക)
[1, 2, 4, 3]

നിഘണ്ടു ശൈലിയിലുള്ള ഒരു കീവേഡ് ആർഗ്യുമെന്റ് നിർമ്മാണവും ഇതുപോലെ കാണപ്പെടുന്നു:

(മറ്റൊരു ശൈലി നിർവചിക്കുക [&കീ {"കീ1" "val1" "കീ2" "val2"}]
[കീ1 കീ2])

ഒരു നിഘണ്ടു ആയതിനാൽ, നിങ്ങൾക്ക് ഒരു പ്രത്യേക കാര്യത്തിലും ആശ്രയിക്കാൻ കഴിയില്ല എന്നതാണ് ഇവിടെയുള്ള വ്യത്യാസം
വാദങ്ങൾക്ക് ഉത്തരവിടുന്നു.

ഹൈയും പിന്തുണയ്ക്കുന്നു *ആർഗ്സ് ഒപ്പം **kwargs. പൈത്തണിൽ:

def some_func(foo, bar, *args, **kwargs):
പ്രിന്റ് ഇറക്കുമതി ചെയ്യുക
pprint.pprint((foo, bar, args, kwargs))

ഹൈ തത്തുല്യം:

(ഫ്യൂ ബാർ & റെസ്റ്റ് ആർഗ്സ് & ക്വാർഗ്സ് ക്വാർഗ്സ്)
(ഇറക്കുമതി പ്രിന്റ്)
(pprint.pprint (, foo bar args kwargs)))

അവസാനമായി, തീർച്ചയായും ഞങ്ങൾക്ക് ക്ലാസുകൾ ആവശ്യമാണ്! പൈത്തണിൽ, നമുക്ക് ഇതുപോലുള്ള ഒരു ക്ലാസ് ഉണ്ടായിരിക്കാം:

ക്ലാസ് ഫൂബാർ(വസ്തു):
"" "
മറ്റൊരു ഉദാഹരണ ക്ലാസ്
"" "
def __init__(സ്വയം, x):
self.x = x

def get_x(self):
"" "
ഞങ്ങളുടെ x പകർപ്പ് തിരികെ നൽകുക
"" "
തിരികെ self.x

ഹൈയിൽ:

(defclass FooBar [object]
"മറ്റൊരു ഉദാഹരണം ക്ലാസ്"
[[--init--
(fn [self x]
(setv self.xx)
; --init--ന് നിലവിൽ ആവശ്യമാണ്, കാരണം __init__ ന് ഒന്നും ആവശ്യമില്ല
; ഇത് ഇല്ലാതാകുമെന്ന് പ്രതീക്ഷിക്കുന്നു :)
ഒന്നുമില്ല)]

[ഗെറ്റ്-എക്സ്
(fn [സ്വയം]
"ഞങ്ങളുടെ x പകർപ്പ് തിരികെ നൽകുക"
self.x)]])

നിങ്ങൾക്ക് ക്ലാസ്-ലെവൽ ആട്രിബ്യൂട്ടുകളും ചെയ്യാം. പൈത്തണിൽ:

ക്ലാസ് കസ്റ്റമർ(മോഡലുകൾ. മോഡൽ):
പേര് = മോഡലുകൾ.CharField(max_length=255)
വിലാസം = models.TextField()
കുറിപ്പുകൾ = മോഡലുകൾ.TextField()

ഹൈയിൽ:

(defclass Customer [models.Model]
[[പേര് (models.CharField :max-length 255})]
[വിലാസം (models.TextField)]
[കുറിപ്പുകൾ (models.TextField)]])

Hy <-> പൈത്തൺ interop
ഹൈ ഇറക്കുമതി ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് പൈത്തണിൽ നിന്ന് നേരിട്ട് ഹൈ ഉപയോഗിക്കാം!

ഇനിപ്പറയുന്നവ നിങ്ങൾ സംരക്ഷിക്കുകയാണെങ്കിൽ ആശംസകൾ.hy:

(defn ആശംസ [പേര്] ("ഹലോ ഫ്രം ഹൈ," പേര് അച്ചടിക്കുക))

മൊഡ്യൂൾ ഇമ്പോർട്ടുചെയ്യുന്നതിന് മുമ്പ് hy ഇമ്പോർട്ടുചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് പൈത്തണിൽ നിന്ന് നേരിട്ട് ഇത് ഉപയോഗിക്കാം. ഇൻ
പൈത്തൺ:

ഇറക്കുമതി hy
ആശംസകൾ ഇറക്കുമതി ചെയ്യുക

ആശംസകൾ. ആശംസകൾ ("ഫൂ")

നിങ്ങൾക്ക് പൈത്തണിൽ (അല്ലെങ്കിൽ ഒരു ക്ലാസ്സിൽ പോലും!) ഒരു ഫംഗ്‌ഷൻ പ്രഖ്യാപിക്കുകയും അത് Hy!-ൽ ഉപയോഗിക്കുകയും ചെയ്യാം.

ഇനിപ്പറയുന്നവ നിങ്ങൾ സംരക്ഷിക്കുകയാണെങ്കിൽ ആശംസകൾ.py പൈത്തണിൽ:

ഡെഫ് ആശംസ(പേര്):
പ്രിന്റ് ("ഹലോ, %s" % (പേര്))

നിങ്ങൾക്ക് ഇത് ഹൈയിൽ ഉപയോഗിക്കാം:

(ആശംസകൾ ഇറക്കുമതി ചെയ്യുക)
(.ആശംസകൾ "ഫൂ")

കീവേഡ് ആർഗ്യുമെന്റുകൾ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് ഉപയോഗിക്കാം ആശംസകൾ.py:

ഡെഫ് ആശംസ(പേര്, തലക്കെട്ട്="സർ"):
പ്രിന്റ് ("ആശംസകൾ, %s %s" % (ശീർഷകം, പേര്))

(ആശംസകൾ ഇറക്കുമതി ചെയ്യുക)
(.ആശംസകൾ "ഫൂ")
(.ആശംസകൾ "ഫൂ" "ഡാർത്ത്")
(അപേക്ഷിക്കുക (. ആശംസകൾ ആശംസകൾ) ["Foo"] {"title" "Lord"})

ഏത് ഔട്ട്പുട്ട് ചെയ്യും:

ആശംസകൾ, സർ ഫൂ

ആശംസകൾ, ഡാർത്ത് ഫൂ

ആശംസകൾ, ഫൂ പ്രഭു

പ്രോട്ടിപ്പുകൾ!
"ത്രെഡിംഗ് മാക്രോ" എന്നറിയപ്പെടുന്ന ചിലതും ഹൈ ഫീച്ചർ ചെയ്യുന്നു, ഇത് വളരെ ഭംഗിയുള്ള ഒരു സവിശേഷതയാണ്
ക്ലോജൂറിന്റേത്. "ത്രെഡിംഗ് മാക്രോ" (ഇങ്ങനെ എഴുതിയിരിക്കുന്നു ->) ആഴത്തിലുള്ള കൂടുണ്ടാക്കുന്നത് ഒഴിവാക്കാൻ ഉപയോഗിക്കുന്നു
ഭാവങ്ങൾ.

ത്രെഡിംഗ് മാക്രോ ഓരോ എക്‌സ്‌പ്രഷനും അടുത്ത എക്‌സ്‌പ്രഷനിലെ ആദ്യ ആർഗ്യുമെന്റിലേക്ക് തിരുകുന്നു
പകരം.

നമുക്ക് ക്ലാസിക് എടുക്കാം:

(ലൂപ്പ് (പ്രിന്റ് (ഇവൽ (വായിക്കുക))))

അങ്ങനെ എഴുതുന്നതിനുപകരം, നമുക്ക് ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ എഴുതാം:

(-> (വായിക്കുക) (eval) (പ്രിന്റ്) (ലൂപ്പ്))

ഇപ്പോൾ, ഉപയോഗിക്കുന്നു പൈത്തൺ-ഷ്, ത്രെഡിംഗ് മാക്രോ എങ്ങനെയെന്ന് നമുക്ക് കാണിക്കാം (പൈത്തൺ-ഷിന്റെ സജ്ജീകരണം കാരണം)
ഒരു പൈപ്പ് പോലെ ഉപയോഗിക്കാം:

=> (ഇറക്കുമതി [sh [cat grep wc]])
=> (-> (പൂച്ച "/usr/share/dict/words") (grep "-E" "^hy") (wc "-l"))
210

ഏത്, തീർച്ചയായും, ഇതിലേക്ക് വികസിക്കുന്നു:

(wc (grep (cat "/usr/share/dict/words") "-E" "^hy") "-l")

കൂടുതൽ വായിക്കാൻ കഴിയും, അല്ലേ? ത്രെഡിംഗ് മാക്രോ ഉപയോഗിക്കുക!

HY ശൈലി ഗൈഡ്

“നിങ്ങൾക്കറിയാം, മന്ത്രി, ഞാൻ ഡംബിൾഡോറിനോട് പല കാര്യങ്ങളിലും വിയോജിക്കുന്നു… പക്ഷേ നിങ്ങൾക്ക് അദ്ദേഹത്തെ നിഷേധിക്കാൻ കഴിയില്ല.
സ്റ്റൈൽ കിട്ടി..." - ഫിനാസ് നിഗല്ലസ് ബ്ലാക്ക്, ഹാരി പോട്ടർ ഒപ്പം The ഓർഡർ of The ഫീനിക്സ്

ഹൈ സ്‌റ്റൈൽ ഗൈഡ് ഹൈവിനുള്ള അടിസ്ഥാന നിയമങ്ങളുടെ ഒരു കൂട്ടമാണ് ഉദ്ദേശിക്കുന്നത് (അതെ, ഹൈ കമ്മ്യൂണിറ്റി
എല്ലാത്തിനും ഹൈ ചേർക്കുന്നതിൽ അഭിമാനിക്കുന്നു) ഭാഷാപരമായ ഹൈ കോഡ് എഴുതാൻ. ഹൈ ധാരാളം ലഭിക്കുന്നു
പൈത്തൺ ഇന്ററോപബിലിറ്റി നിലനിർത്തിക്കൊണ്ടുതന്നെ, ക്ലോജ്യൂറിൽ നിന്നും കോമൺ ലിസ്‌പിൽ നിന്നും.

പ്രെൾഡ്
ദി താവോ of Hy
ഉമ്മൻ പ്രധാന സന്യാസിയോട് ചോദിച്ചു, "താങ്കൾ എന്ത് സൂത്രത്തിലാണ് പ്രസംഗിക്കുന്നത്?"
"നിർവാണസൂത്രം."
"നിർവാണസൂത്രത്തിന് നാല് ഗുണങ്ങളുണ്ട്, അല്ലേ?"
"അതുണ്ട്."
ഉമ്മൻ ഒരു കപ്പ് എടുത്ത് ചോദിച്ചു, "ഇതിന് എത്ര പുണ്യമുണ്ട്?"
“ഒന്നുമില്ല,” സന്യാസി പറഞ്ഞു.
"എന്നാൽ പുരാതന ആളുകൾ അത് ഉണ്ടെന്ന് പറഞ്ഞു, അല്ലേ?" ഉമ്മൻ പറഞ്ഞു.
"അവർ പറഞ്ഞതിനെക്കുറിച്ച് നിങ്ങൾക്ക് എന്തു തോന്നുന്നു?"
ഉമ്മൻ കപ്പിൽ തട്ടി ചോദിച്ചു, "നിനക്ക് മനസ്സിലായോ?"
"ഇല്ല," സന്യാസി പറഞ്ഞു.
"അപ്പോൾ," ഉമ്മൻ പറഞ്ഞു, "നിങ്ങൾ സൂത്രത്തെക്കുറിച്ചുള്ള നിങ്ങളുടെ പ്രഭാഷണങ്ങൾ തുടരുന്നതാണ് നല്ലത്."
- (കോൺ) മാക്രോ

നിർമ്മാണത്തിലേക്ക് പോയ ഡിസൈൻ തീരുമാനങ്ങളുടെ ഒരു ഹ്രസ്വ ലിസ്റ്റ് ഇനിപ്പറയുന്നത് വ്യക്തമാക്കുന്നു
ഹൈ.

ഒരു ലിസ്പ് പോലെ കാണുക; അതിനൊപ്പം DTRT (ഉദാഹരണത്തിന്, ഡാഷുകൾ അടിവരയിലേയ്ക്ക് മാറുന്നു, ഇയർമഫുകൾ തിരിയുന്നു
എല്ലാ തൊപ്പികളും).

· ഞങ്ങൾ ഇപ്പോഴും പൈത്തൺ ആണ്. മിക്ക ഇന്റേണലുകളും 1:1 എന്നത് പൈത്തൺ ഇന്റേണലുകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.

· എല്ലായിടത്തും യൂണികോഡ് ഉപയോഗിക്കുക.

പൈത്തൺ 2 ലെ തെറ്റായ തീരുമാനങ്ങൾ നമുക്ക് കഴിയുമ്പോൾ പരിഹരിക്കുക (കാണുക സത്യ_വിഭജനം).

· സംശയമുണ്ടെങ്കിൽ, പൈത്തണിലേക്ക് മാറ്റിവയ്ക്കുക.

· നിങ്ങൾക്ക് ഇപ്പോഴും ഉറപ്പില്ലെങ്കിൽ, ക്ലോജൂറിലേക്ക് മാറ്റിവയ്ക്കുക.

· നിങ്ങൾക്ക് കൂടുതൽ ഉറപ്പില്ലെങ്കിൽ, Common Lisp-ലേക്ക് മാറ്റിവെക്കുക.

· ഞങ്ങൾ ക്ലോജർ അല്ലെന്ന് ഓർമ്മിക്കുക. ഞങ്ങൾ കോമൺ ലിസ്പ് അല്ല. ഞങ്ങൾ ഹോമോകോണിക് പൈത്തൺ ആണ്
അർത്ഥമുള്ള അധിക ബിറ്റുകൾ.

ലേഔട്ട് & ഇൻഡന്റേഷൻ
· ട്രെയിലിംഗ് സ്പേസുകൾ ഒഴിവാക്കുക. അവർ മുലകുടിക്കുന്നു!

· ഇൻഡന്റേഷൻ 2 സ്‌പെയ്‌സുകളായിരിക്കണം (ഹാർഡ് ടാബുകൾ ഇല്ല), എന്നതിന്റെ ഇൻഡന്റേഷനുമായി പൊരുത്തപ്പെടുമ്പോൾ ഒഴികെ
മുമ്പത്തെ വരി.

;; നല്ലത് (ഒപ്പം മുൻഗണനയും)
(defn fib [n]
(എങ്കിൽ (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; ഇപ്പോഴും കുഴപ്പമില്ല
(defn fib [n]
(<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; ഇപ്പോഴും കുഴപ്പമില്ല
(defn fib [n]
(എങ്കിൽ (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; ഉന്മാദമായി പരിഹാസ്യമാണ്
(defn fib [n]
(എങ്കിൽ (<= n 2)
n ;; അതെ, ക്രമരഹിതമായി സ്പേസ് കീ അമർത്തുന്നത് ഞാൻ ഇഷ്ടപ്പെടുന്നു
(+ (fib (- n 1)) (fib (- n 2)))))

· പരാൻതീസിസ് നിർബന്ധമായും ഒരിക്കലും അവരുടെ സ്വന്തം ലൈനിൽ ഏകാകികളും ദുഃഖിതരും ഏകാന്തതയുമുള്ളവരായിരിക്കുക.

;; നല്ലത് (ഒപ്പം മുൻഗണനയും)
(defn fib [n]
(എങ്കിൽ (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; ഉന്മാദമായി പരിഹാസ്യമാണ്
(defn fib [n]
(എങ്കിൽ (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
); GAH, അത് തീയിൽ കത്തിക്കുക

· ലംബമായി വിന്യസിക്കുക ചെയ്യട്ടെ ബ്ലോക്കുകൾ.

(ആവട്ടെ [[foo (ബാർ)]
[Qux (baz)]]
(foo qux))

ഇൻലൈൻ കമന്റുകൾ കോഡിന്റെ അവസാനം മുതൽ രണ്ട് സ്‌പെയ്‌സ് ആയിരിക്കണം; അവർക്ക് എപ്പോഴും ഒരു ഉണ്ടായിരിക്കണം
കമന്റ് പ്രതീകത്തിനും കമന്റിന്റെ തുടക്കത്തിനും ഇടയിലുള്ള ഇടം. കൂടാതെ, ചെയ്യാതിരിക്കാൻ ശ്രമിക്കുക
വ്യക്തമായ അഭിപ്രായം.

;; നല്ലത്
(setv ind (ഡിസം x)) ; സൂചിക 0 മുതൽ ആരംഭിക്കുന്നു

;; ശൈലിക്ക് അനുസൃതമാണെങ്കിലും വ്യക്തമായത് പ്രസ്താവിക്കുന്നു
(setv ind (ഡിസം x)) ; സൂചിക x-1 ആയി സജ്ജമാക്കുന്നു

;; മോശം
(setv ind (dec x)); വിനോദത്തിനായി വാക്കുകൾ ടൈപ്പുചെയ്യുന്നു

കോഡിംഗ് ശൈലി
· ഒരു കൺവെൻഷൻ എന്ന നിലയിൽ, ഉപയോഗിക്കാതിരിക്കാൻ ശ്രമിക്കുക മാഷ് ആഗോള വേരിയബിളുകൾ ഒഴികെ മറ്റെന്തിനും; ഉപയോഗിക്കുക setv
അകത്തുള്ള പ്രവർത്തനങ്ങൾ, ലൂപ്പുകൾ മുതലായവ.

;; നല്ലത് (ഒപ്പം മുൻഗണനയും)
(def *പരിധി* 400000)

(defn fibs [ab]
(സത്യമാണെങ്കിലും
(വിളവ് എ)
(setv (, ab) (, b (+ ab)))))

;; മോശം (ഒപ്പം അഭികാമ്യമല്ല)
(defn fibs [ab]
(സത്യമാണെങ്കിലും
(വിളവ് എ)
(def (, ab) (, b (+ ab)))))

· വെക്റ്റർ വാക്യഘടന ഉദ്ദേശിക്കുന്നിടത്ത് s-എക്സ്പ്രഷൻ സിന്റാക്സ് ഉപയോഗിക്കരുത്. ഉദാഹരണത്തിന്, വസ്തുത
ഈ രണ്ട് ഉദാഹരണങ്ങളിൽ ആദ്യത്തേത് പ്രവർത്തിക്കുന്നത് കംപൈലർ അമിതമല്ലാത്തതുകൊണ്ടാണ്
കണിശമായ. വാസ്തവത്തിൽ, ഇതുപോലുള്ള സ്ഥലങ്ങളിലെ ശരിയായ വാക്യഘടന രണ്ടാമത്തേതാണ്.

;; മോശം (തിന്മയും)
(defn foo (x) (print x))
(foo 1)

;; നല്ലത് (ഒപ്പം മുൻഗണനയും)
(defn foo [x] (print x))
(foo 1)

ആഴത്തിൽ കൂടുകൂട്ടുമ്പോൾ ത്രെഡിംഗ് മാക്രോ അല്ലെങ്കിൽ ത്രെഡിംഗ് ടെയിൽ മാക്രോകൾ ഉപയോഗിക്കുക
s- എക്സ്പ്രഷനുകൾ. എന്നിരുന്നാലും, അവ ഉപയോഗിക്കുമ്പോൾ സൂക്ഷ്മത പുലർത്തുക. വ്യക്തതയുള്ളപ്പോൾ അവ ഉപയോഗിക്കുക
വായനാക്ഷമത മെച്ചപ്പെടുന്നു; വളഞ്ഞതും മനസ്സിലാക്കാൻ പ്രയാസമുള്ളതുമായ പദപ്രയോഗങ്ങൾ നിർമ്മിക്കരുത്.

;; മുൻഗണന
(def *പേരുകൾ*
([f ("names.txt" തുറക്കുക")]
(-> (.റീഡ് എഫ്) (.സ്ട്രിപ്പ്) (. "\"" "" മാറ്റിസ്ഥാപിക്കുക) (.സ്പ്ലിറ്റ് ",") (ക്രമീകരിച്ചത്))))

;; അത്ര നല്ലതല്ല
(def *പേരുകൾ*
([f ("names.txt" തുറക്കുക")]
(ക്രമീകരിച്ചത് (.സ്പ്ലിറ്റ് "," (. "\"" "" (.സ്ട്രിപ്പ് (.റീഡ് എഫ്)))))))

;; ഒരുപക്ഷേ നല്ല ആശയമല്ല
(defn സ്ക്വയർ? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

ഒബ്‌ജക്‌റ്റിന്റെ രീതിയുടെ നേരിട്ടുള്ള കോളിനേക്കാൾ ക്ലോജൂർ-സ്റ്റൈൽ ഡോട്ട് നൊട്ടേഷനാണ് തിരഞ്ഞെടുക്കുന്നത്,
എങ്കിലും രണ്ടും പിന്തുണയ്ക്കുന്നത് തുടരും.

;; നല്ലത്
([fd (ഓപ്പൺ") ഉപയോഗിച്ച്/ etc / passwd")]
(പ്രിന്റ് (.readlines fd)))

;; അത്ര നല്ലതല്ല
([fd (ഓപ്പൺ") ഉപയോഗിച്ച്/ etc / passwd")]
(പ്രിന്റ് (fd.readlines)))

തീരുമാനം
"ഫാഷനുകൾ മങ്ങുന്നു, ശൈലി ശാശ്വതമാണ്" -യെവ്സ് സെന്റ് ലോറന്റ്

ഈ ഗൈഡ് കമ്മ്യൂണിറ്റി മാർഗ്ഗനിർദ്ദേശങ്ങളുടെ ഒരു കൂട്ടം മാത്രമാണ്, വ്യക്തമായും, കമ്മ്യൂണിറ്റി മാർഗ്ഗനിർദ്ദേശങ്ങൾ ചെയ്യുന്നു
സജീവമായ ഒരു കമ്മ്യൂണിറ്റി ഇല്ലാതെ അർത്ഥമില്ല. സംഭാവനകൾ സ്വാഗതം ചെയ്യുന്നു. #hy in എന്നതിൽ ഞങ്ങളോടൊപ്പം ചേരൂ
ഫ്രീനോഡ്, അതിനെക്കുറിച്ച് ബ്ലോഗ്, അതിനെക്കുറിച്ച് ട്വീറ്റ്, ഏറ്റവും പ്രധാനമായി, ഹൈ ഉപയോഗിച്ച് ആസ്വദിക്കൂ.

നന്ദി
· ഈ ഗൈഡ് വളരെയധികം പ്രചോദനം ഉൾക്കൊണ്ടതാണ് @പോൾടാഗ് ന്റെ ബ്ലോഗ് പോസ്റ്റ് Hy അതിജീവനം വഴികാട്ടി

· ദി ക്ലോജൂർ ശൈലി വഴികാട്ടി

പ്രമാണീകരണം INDEX

ഉള്ളടക്കം:

കമാൻഡ് വര ഇന്റര്ഫേസ്
hy
കമാൻഡ് വര ഓപ്ഷനുകൾ
-c
ഹൈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക കമാൻഡ്.

$ hy -c "(പ്രിന്റ് (+ 2 2))"
4

-i
ഹൈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക കമാൻഡ്, തുടർന്ന് REPL-ൽ തുടരുക.

-m
ഹൈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക മൊഡ്യൂൾഉൾപ്പെടെ defmain നിർവചിച്ചാൽ.

ദി -m ഫ്ലാഗ് ഓപ്‌ഷൻ ലിസ്റ്റ് അവസാനിപ്പിക്കുന്നു, അങ്ങനെ എല്ലാ ആർഗ്യുമെന്റുകളും ശേഷം മൊഡ്യൂൾ പേര്
ലെ മൊഡ്യൂളിലേക്ക് കൈമാറുന്നു sys.argv.

0.10.2 പതിപ്പിൽ പുതിയത്.

--ചാരൻ എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് തത്തുല്യമായ പൈത്തൺ കോഡ് പ്രിന്റ് ചെയ്യുക. ഉദാഹരണത്തിന്:

=> (defn salutationsnm [name] (+ "Hy " name "!")))
def salutationsnm(പേര്):
പ്രിന്റ് തിരികെ നൽകുക(((u'Hy ' + name) + u'!'))
=> ("നിങ്ങളുടെ പേര്" അഭിവാദ്യങ്ങൾ)
അഭിവാദനങ്ങൾ (നിങ്ങളുടെ പേര്')
നിങ്ങളുടെ പേര്!
=>

0.9.11 പതിപ്പിൽ പുതിയത്.

--ഷോ-ട്രേസ്ബാക്കുകൾ
ഹൈ ഒഴിവാക്കലുകൾക്കായി വിപുലീകൃത ട്രേസ്ബാക്കുകൾ പ്രിന്റ് ചെയ്യുക.

0.9.12 പതിപ്പിൽ പുതിയത്.

-v ഹൈ പതിപ്പ് നമ്പർ പ്രിന്റ് ചെയ്‌ത് പുറത്തുകടക്കുക.

ഹൈക്
കമാൻഡ് വര ഓപ്ഷനുകൾ
ഫയൽ[, ഫയൽN]
ഹൈ കോഡ് പൈത്തൺ ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുക. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ് ഇതായി സേവ് ചെയ്യുക
hyname.hy:

(defn hy-hy [പേര്]
(+ "Hy " name "!")))

(ഹൈ-ഹൈ "ആഫ്രോമാൻ")

തുടർന്ന് പ്രവർത്തിപ്പിക്കുക:

$ hyc hyname.hy
$ പൈത്തൺ hyname.pyc
ഹായ് അഫ്രോമാൻ!

hy2py
0.10.1 പതിപ്പിൽ പുതിയത്.

കമാൻഡ് വര ഓപ്ഷനുകൾ
-s

--ഉറവിടത്തോടെ
പാഴ്‌സ് ചെയ്‌ത ഉറവിട ഘടന കാണിക്കുക.

-a

--with-ast
സൃഷ്ടിച്ച AST കാണിക്കുക.

-np

--പൈത്തൺ ഇല്ലാതെ
AST-ൽ നിന്ന് സൃഷ്ടിച്ച പൈത്തൺ കോഡ് കാണിക്കരുത്.

Hy (ദി ഭാഷ)
മുന്നറിയിപ്പ്:
ഇത് അപൂർണ്ണമാണ്; ഡോക്യുമെന്റേഷൻ ശ്രമത്തിൽ സംഭാവന ചെയ്യുന്നത് പരിഗണിക്കുക.

സിദ്ധാന്തം of Hy
പൈത്തണുമായി രണ്ട് ദിശകളിലും 100% അനുയോജ്യത ഹൈ നിലനിർത്തുന്നു
തന്നെ. എല്ലാ ഹൈ കോഡും കുറച്ച് ലളിതമായ നിയമങ്ങൾ പാലിക്കുന്നു. ഇത് വരാൻ പോകുന്നതിനാൽ ഇത് ഓർമ്മിക്കുക
ഹാൻഡി.

ഹൈ കോഡ് ഭാഷാപരമായതും രണ്ട് ഭാഷകളിലും ഇന്റർഫേസ് ചെയ്യാവുന്നതുമാണെന്ന് ഉറപ്പാക്കാൻ ഈ നിയമങ്ങൾ സഹായിക്കുന്നു.

· ഇയർമഫുകളിലെ ചിഹ്നങ്ങൾ ആ സ്ട്രിംഗിന്റെ അപ്പർ-കേസ് പതിപ്പിലേക്ക് വിവർത്തനം ചെയ്യും. വേണ്ടി
ഉദാഹരണത്തിന്, ഫൂ ആയിത്തീരും FOO.

· UTF-8 എന്റിറ്റികൾ ഉപയോഗിച്ച് എൻകോഡ് ചെയ്യപ്പെടും പുന്കോഡ് കൂടെ പ്രിഫിക്സും ഹൈ_. ഉദാഹരണത്തിന്, ⚘
ആയിത്തീരും hy_w7h, ♥ ആയിത്തീരും hy_g6h, ഒപ്പം i♥u ആയിത്തീരും hy_iu_t0x.

· ഡാഷുകൾ അടങ്ങുന്ന ചിഹ്നങ്ങൾ അണ്ടർസ്കോറുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും. ഉദാഹരണത്തിന്,
റെൻഡർ-ടെംപ്ലേറ്റ് ആയിത്തീരും റെൻഡർ_ടെംപ്ലേറ്റ്. ഇതിനർത്ഥം ഡാഷുകളുള്ള ചിഹ്നങ്ങൾ ആയിരിക്കും എന്നാണ്
നിഴൽ അവയുടെ അടിവരയിട്ട തത്തുല്യങ്ങൾ, തിരിച്ചും.

ബിൽറ്റ്-ഇന്നുകൾ
കൃത്യമായ പൈത്തൺ AST സൃഷ്ടിക്കാൻ സഹായിക്കുന്ന നിരവധി പ്രത്യേക ഫോമുകൾ Hy ഫീച്ചർ ചെയ്യുന്നു.
ഇനിപ്പറയുന്നവ "പ്രത്യേക" ഫോമുകളാണ്, അവയ്ക്ക് അൽപ്പം അപ്രതീക്ഷിതമായ പെരുമാറ്റമുണ്ടാകാം
ചില സാഹചര്യങ്ങൾ.

.
0.10.0 പതിപ്പിൽ പുതിയത്.

. ഒബ്ജക്റ്റുകളിൽ ആട്രിബ്യൂട്ട് ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. വേഗത്തിൽ അനുവദിക്കുന്നതിന് ഇത് ഒരു ചെറിയ DSL ഉപയോഗിക്കുന്നു
ഒരു നെസ്റ്റഡ് ഡാറ്റാ ഘടനയിലെ ആട്രിബ്യൂട്ടുകളിലേക്കും ഇനങ്ങളിലേക്കും പ്രവേശനം.

ഉദാഹരണത്തിന്,

(. ഫൂ ബാർ ബാസ് [(+ 1 2)] ഫ്രോബ്)

ഇതിലേക്ക് കംപൈൽ ചെയ്യുന്നു:

foo.bar.baz[1 + 2].frob

. അതിന്റെ ആദ്യ വാദം സമാഹരിക്കുന്നു (ഉദാഹരണത്തിൽ, ഫൂ) ചെയ്യേണ്ട വസ്തുവായി
ആട്രിബ്യൂട്ട് dereference. ഇത് ആക്‌സസ് ചെയ്യുന്നതിനുള്ള ആട്രിബ്യൂട്ടുകളായി നഗ്നമായ ചിഹ്നങ്ങൾ ഉപയോഗിക്കുന്നു (ഉദാഹരണത്തിൽ, ബാർ,
അടിത്തറ, ഫ്രോബ്), കൂടാതെ ലിസ്റ്റുകളുടെ ഉള്ളടക്കങ്ങൾ സമാഹരിക്കുന്നു (ഉദാഹരണത്തിൽ, [(+ 1 2)]) സൂചികയ്ക്കായി.
മറ്റ് ആർഗ്യുമെന്റുകൾ ഒരു സമാഹാര പിശക് ഉണ്ടാക്കുന്നു.

അജ്ഞാതമായ ആട്രിബ്യൂട്ടുകളിലേക്കുള്ള ആക്സസ് എറിയുന്നു ആട്രിബ്യൂട്ട് പിശക്. അജ്ഞാത കീകളിലേക്കുള്ള ആക്സസ് ഒരു എറിയുന്നു
സൂചിക പിശക് (ലിസ്റ്റുകളിലും ട്യൂപ്പിലുകളിലും) അല്ലെങ്കിൽ എ കീ പിശക് (നിഘണ്ടുക്കളിൽ).

->
-> (അഥവാ ത്രെഡിംഗ് മാക്രോ) എക്സ്പ്രഷനുകളുടെ നെസ്റ്റിംഗ് ഒഴിവാക്കാൻ ഉപയോഗിക്കുന്നു. ത്രെഡിംഗ് മാക്രോ
ഓരോ എക്സ്പ്രഷനും അടുത്ത എക്സ്പ്രഷന്റെ ആദ്യ ആർഗ്യുമെന്റ് സ്ഥലത്തേക്ക് തിരുകുന്നു. ഇനിപ്പറയുന്നവ
കോഡ് ഇത് കാണിക്കുന്നു:

=> (defn output [ab] (print ab))
=> (-> (+ 4 6) (ഔട്ട്പുട്ട് 5))
10 5

- >>
- >> (അഥവാ ത്രെഡിംഗ് വാൽ മാക്രോ) എന്നതിന് സമാനമാണ് ത്രെഡിംഗ് മാക്രോ, എന്നാൽ പകരം
ഓരോ പദപ്രയോഗവും അടുത്ത പദപ്രയോഗത്തിന്റെ ആദ്യ ആർഗ്യുമെന്റിലേക്ക് തിരുകുമ്പോൾ, അത് അതിനെ ഇങ്ങനെ കൂട്ടിച്ചേർക്കുന്നു
അവസാന വാദം. ഇനിപ്പറയുന്ന കോഡ് ഇത് കാണിക്കുന്നു:

=> (defn output [ab] (print ab))
=> (->> (+ 4 6) (ഔട്ട്പുട്ട് 5))
5 10

പ്രയോഗിക്കുക
പ്രയോഗിക്കുക ആർഗ്യുമെന്റുകളുടെ ഒരു ഓപ്ഷണൽ ലിസ്റ്റും kwargs-ന്റെ ഒരു ഓപ്ഷണൽ നിഘണ്ടുവും പ്രയോഗിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു ചടങ്ങിലേക്ക്.

ഉപയോഗം: (അപേക്ഷിക്കുക fn-നാമം [args] [kwargs])

ഉദാഹരണങ്ങൾ:

(defn Thunk []
"ഹാ അവിടെ")

(തങ്ക് പ്രയോഗിക്കുക)
;=> "ഹാ അവിടെ"

(മൊത്തം വാങ്ങൽ defn [വില തുക & ഓപ്ഷണൽ [ഫീസ് 1.05] [വാറ്റ് 1.1]]
(* വില തുക ഫീസ് വാറ്റ്))

(മൊത്തം വാങ്ങൽ പ്രയോഗിക്കുക [10 15])
;=> 173.25

(മൊത്തം വാങ്ങൽ [10 15] {"vat" 1.05} പ്രയോഗിക്കുക)
;=> 165.375

(മൊത്തം വാങ്ങൽ പ്രയോഗിക്കുക [] {"വില" 10 "തുക" 15 "വാറ്റ്" 1.05})
;=> 165.375

ഒപ്പം
ഒപ്പം ലോജിക്കൽ എക്സ്പ്രഷനുകളിൽ ഉപയോഗിക്കുന്നു. ഇതിന് കുറഞ്ഞത് രണ്ട് പാരാമീറ്ററുകൾ ആവശ്യമാണ്. എല്ലാ പാരാമീറ്ററുകളും ആണെങ്കിൽ
വരെ വിലയിരുത്തുക ട്രൂ, അവസാന പാരാമീറ്റർ തിരികെ നൽകി. മറ്റേതെങ്കിലും സാഹചര്യത്തിൽ, ആദ്യത്തെ തെറ്റായ മൂല്യം
തിരികെ നൽകും. ഉദാഹരണ ഉപയോഗം:

=> (ശരി തെറ്റും)
തെറ്റായ

=> (ഒപ്പം ശരിയും)
ട്രൂ

=> (ഒപ്പം ശരി 1)
1

=> (ഒപ്പം ശരി [] തെറ്റ് ശരി)
[]

ശ്രദ്ധിക്കുക:
ഒപ്പം ഷോർട്ട് സർക്യൂട്ടുകളും ആദ്യ തെറ്റ് വന്നയുടൻ പാരാമീറ്ററുകൾ വിലയിരുത്തുന്നത് നിർത്തുന്നു
നേരിട്ടു.

=> (ഒപ്പം തെറ്റും ("ഹലോ" എന്ന് അച്ചടിക്കുക))
തെറ്റായ

ഉറപ്പിക്കുക
ഉറപ്പിക്കുക പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ വ്യവസ്ഥകൾ പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു. വ്യവസ്ഥ ഇല്ലെങ്കിൽ
കണ്ടുമുട്ടി, ഒരു അസെർഷൻപിശക് ഉയർത്തിയിരിക്കുന്നു. ഉറപ്പിക്കുക ഒന്നോ രണ്ടോ പാരാമീറ്ററുകൾ എടുത്തേക്കാം. ആദ്യത്തേത്
പരാമീറ്റർ എന്നത് പരിശോധിക്കേണ്ട അവസ്ഥയാണ്, അത് ഒന്നുകിൽ വിലയിരുത്തണം ട്രൂ or തെറ്റായ. ദി
രണ്ടാമത്തെ പാരാമീറ്റർ, ഓപ്ഷണൽ, ഉറപ്പിക്കുന്നതിനുള്ള ഒരു ലേബൽ ആണ്, അതായിരിക്കും സ്ട്രിംഗ്
കൂടെ ഉയർത്തി അസെർഷൻപിശക്. ഉദാഹരണത്തിന്:

(അുറപ്പിക്കുക (= വേരിയബിൾ പ്രതീക്ഷിക്കുന്ന മൂല്യം))

(തെറ്റാണെന്ന് ഉറപ്പിക്കുക)
; അസെർഷൻപിശക്

(= 1 2) "ഒന്ന് രണ്ട് തുല്യമായിരിക്കണം")
; അവകാശവാദ പിശക്: ഒന്ന് രണ്ട് തുല്യമായിരിക്കണം

അസോക്ക്
അസോക്ക് ഒരു നിഘണ്ടുവിലെ മൂല്യവുമായി ഒരു കീ ബന്ധപ്പെടുത്തുന്നതിനോ ഒരു പട്ടികയുടെ ഒരു സൂചിക സജ്ജമാക്കുന്നതിനോ ഉപയോഗിക്കുന്നു
ഒരു മൂല്യത്തിലേക്ക്. ഇതിന് കുറഞ്ഞത് മൂന്ന് പാരാമീറ്ററുകൾ ആവശ്യമാണ്: ഡാറ്റ ഘടന പരിഷ്കരിക്കാൻ, എ കീ
or സൂചിക, ഒരു മൂല്യം. മൂന്നിൽ കൂടുതൽ പാരാമീറ്ററുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, അത് ജോഡികളായി ബന്ധപ്പെടുത്തും.

ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ:

=>([[ശേഖരം {}]]
... (അസോക് കളക്ഷൻ "ഡോഗ്" "ബാർക്ക്")
... (അച്ചടി ശേഖരം))
{u'Dog': u'Bark'}

=>([[ശേഖരം {}]]
... (അസോക് ശേഖരം "നായ" "കുരു" "പൂച്ച" "മ്യാവൂ")
... (അച്ചടി ശേഖരം))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>([[ശേഖരം [1 2 3 4]]]
... (അസോക് കളക്ഷൻ 2 ഒന്നുമില്ല)
... (അച്ചടി ശേഖരം))
[1, 2, ഒന്നുമില്ല, 4]

ശ്രദ്ധിക്കുക:
അസോക്ക് സ്ഥലത്തെ ഡാറ്റാസ്ട്രക്ചർ പരിഷ്ക്കരിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു ഒന്നുമില്ല.

ഇടവേള
ഇടവേള ഒരു ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ ഉപയോഗിക്കുന്നു. ഇത് ഉടൻ തന്നെ ലൂപ്പ് അവസാനിപ്പിക്കുന്നു. ഇനിപ്പറയുന്നവ
ഉദാഹരണത്തിന് അനന്തതയുണ്ട് സമയത്ത് ഉപയോക്താവ് പ്രവേശിക്കുമ്പോൾ തന്നെ അവസാനിപ്പിക്കുന്ന ലൂപ്പ് k.

(ശരി ആണെങ്കിൽ (= "k" (റോ-ഇൻപുട്ട് "? "))
(ബ്രേക്ക്)
("വീണ്ടും ശ്രമിക്കുക" അച്ചടിക്കുക)))

അവസ്ഥ
അവസ്ഥ നെസ്റ്റഡ് നിർമ്മിക്കാൻ ഉപയോഗിക്കാം if പ്രസ്താവനകൾ. ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു
മാക്രോയും അതിന്റെ വികാസവും തമ്മിലുള്ള ബന്ധം:

(condition [condition-1 result-1]
[അവസ്ഥ-2 ഫലം-2])

(നിബന്ധന-1 ഫലം-1 ആണെങ്കിൽ
(നിബന്ധന-2 ഫലം-2 ആണെങ്കിൽ))

ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ, ആദ്യം പൊരുത്തപ്പെടുന്ന ഫല ബ്ലോക്ക് മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യൂ.

=> (defn check-value [value]
... (cond [(< മൂല്യം 5) ("മൂല്യം 5 നേക്കാൾ ചെറുതാണ്" എന്ന് അച്ചടിക്കുക)]
... [(= മൂല്യം 5) ("മൂല്യം 5 ന് തുല്യമാണ്" എന്ന് അച്ചടിക്കുക)]
... [(> മൂല്യം 5) ("മൂല്യം 5 നേക്കാൾ വലുതാണ്" എന്ന് അച്ചടിക്കുക)]
... [ശരി ("മൂല്യം അത് പാടില്ലാത്ത ഒന്നാണ്")]))

=> (ചെക്ക്-മൂല്യം 6)
മൂല്യം 5-ൽ കൂടുതലാണ്

തുടരുക
തുടരുക ഒരു ലൂപ്പിന്റെ ആരംഭത്തിലേക്ക് എക്സിക്യൂഷൻ തിരികെ നൽകുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ,
(പാർശ്വഫലം1) ഓരോ ആവർത്തനത്തിനും വിളിക്കുന്നു. (പാർശ്വഫലം2), എന്നിരുന്നാലും, വിളിക്കപ്പെടുക മാത്രമാണ് ചെയ്യുന്നത്
പട്ടികയിലെ മറ്റെല്ലാ മൂല്യങ്ങളും.

;; (പാർശ്വഫലം1), (പാർശ്വഫലം2) എന്നിവ ഫംഗ്‌ഷനുകളാണെന്നും
;; സംഖ്യാ മൂല്യങ്ങളുടെ ഒരു പട്ടികയാണ് ശേഖരം

([x ശേഖരത്തിന്]
(ചെയ്യുക
(പാർശ്വഫലം1 x)
(എങ്കിൽ (% x 2)
(തുടരുക))
(പാർശ്വഫലം2 x)))

dict-comp
dict-comp നിഘണ്ടുക്കൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. ഇതിന് മൂന്നോ നാലോ പാരാമീറ്ററുകൾ ആവശ്യമാണ്. ആദ്യത്തേത്
രണ്ട് പരാമീറ്ററുകൾ റിട്ടേൺ മൂല്യം (കീ-മൂല്യ ജോഡി) നിയന്ത്രിക്കുന്നതിനാണ്, മൂന്നാമത്തേത്
ഒരു ശ്രേണിയിൽ നിന്ന് ഇനങ്ങൾ തിരഞ്ഞെടുക്കാൻ ഉപയോഗിക്കുന്നു. നാലാമത്തേതും ഓപ്ഷണൽ പരാമീറ്ററും ഉപയോഗിക്കാം
ഒരു സോപാധിക പദപ്രയോഗത്തെ അടിസ്ഥാനമാക്കി ക്രമത്തിലെ ചില ഇനങ്ങൾ ഫിൽട്ടർ ചെയ്യുക.

=> (ഡിക്ട്-കോംപ് x (* x 2) [x (പരിധി 10)] (ഒറ്റ? x))
{1: 2, 3: 6, 9: 18, 5: 10, 7: 14}

do / പ്രവചനം
do ഒപ്പം പ്രവചനം അവരുടെ ഓരോ വാദഗതികളും വിലയിരുത്താനും അവസാനത്തേത് തിരികെ നൽകാനും ഉപയോഗിക്കുന്നു. മടങ്ങുക
അവസാന ആർഗ്യുമെന്റ് ഒഴികെയുള്ള എല്ലാ മൂല്യങ്ങളും നിരസിച്ചു. ഇത് ഉപയോഗിക്കാവുന്നതാണ് ലാംഡ or
ലിസ്റ്റ്-കോം ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങളിലൊന്നിൽ കാണിച്ചിരിക്കുന്നതുപോലെ കൂടുതൽ സങ്കീർണ്ണമായ യുക്തി നടപ്പിലാക്കാൻ.

ചില ഉദാഹരണ ഉപയോഗം:

=> (ശരി ആണെങ്കിൽ
... (ചെയ്യുക ("പാർശ്വഫലങ്ങൾ പാറ!")
... ("അതെ, ശരിക്കും!")))
പാർശ്വഫലങ്ങൾ പാറ!
അതെ, ശരിക്കും!

;; (പാർശ്വഫലം) ഓരോന്നിനും വേണ്ടി വിളിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു ഫംഗ്‌ഷനാണെന്ന് അനുമാനിക്കുന്നു
;; കൂടാതെ ലിസ്റ്റിലെ എല്ലാ മൂല്യങ്ങളും, എന്നാൽ ആരുടെ റിട്ടേൺ മൂല്യം ഞങ്ങൾ ശ്രദ്ധിക്കുന്നില്ല
=> (list-comp (do (പാർശ്വഫലം x)
... ((< x 5) എങ്കിൽ (* 2 x)
... (* 4 x)))
... (x (പരിധി 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do 1 മുതൽ n വരെയുള്ള എത്ര ആർഗ്യുമെന്റുകളും സ്വീകരിക്കാം.

മാഷ് / setv
മാഷ് ഒപ്പം setv ഒരു മൂല്യം, ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ ഫംഗ്ഷൻ എന്നിവ ഒരു ചിഹ്നവുമായി ബന്ധിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്:

=> (ഡെഫ് പേരുകൾ ["ആലിസ്" "ബോബ്" "ചാർലി"])
=> (പേരുകൾ അച്ചടിക്കുക)
[u'Alice', u'Bob', u'Charlie']

=> (setv കൗണ്ടർ (fn [ശേഖര ഇനം] (.എണ്ണം ശേഖരണ ഇനം)))
=> (കൗണ്ടർ [1 2 3 4 5 2 3] 2)
2

defclass
പുതിയ ക്ലാസുകൾ പ്രഖ്യാപിക്കുന്നു defclass. ഇതിന് രണ്ട് ഓപ്ഷണൽ പാരാമീറ്ററുകൾ എടുക്കാം: ഒരു വെക്റ്റർ
സാധ്യമായ ഒരു സൂപ്പർ ക്ലാസുകളും പുതിയതിന്റെ ആട്രിബ്യൂട്ടുകൾ അടങ്ങിയ മറ്റൊരു വെക്‌ടറും നിർവചിക്കുന്നു
രണ്ട് ഇനം വെക്റ്ററുകളായി ക്ലാസ്.

(defclass class-name [super-class-1 super-class-2]
[[ആട്രിബ്യൂട്ട് മൂല്യം]])

ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ മൂല്യങ്ങളും ഫംഗ്‌ഷനുകളും പുതിയ ക്ലാസിൽ ബന്ധിപ്പിക്കാൻ കഴിയും:

=> (defclass Cat []
... [[പ്രായം ഒന്നുമില്ല]
... [നിറം "വെളുപ്പ്"]
... [സംസാരിക്കുക (fn [self] ("Meow" അച്ചടിക്കുക))]])

=> (ഡെഫ് സ്പോട്ട് (പൂച്ച))
=> (setv spot.colour "Black")
'കറുപ്പ്'
=> (.സ്പീക്ക് സ്പോട്ട്)
മ്യാവു

defn / defun
defn ഒപ്പം defun ഫംഗ്‌ഷനുകൾ നിർവചിക്കാൻ മാക്രോകൾ ഉപയോഗിക്കുന്നു. അവർ മൂന്ന് പാരാമീറ്ററുകൾ എടുക്കുന്നു: പേര്
നിർവചിക്കാനുള്ള പ്രവർത്തനത്തിന്റെ, ഒരു വെക്റ്റർ പാരാമീറ്ററുകൾഎന്നാൽ ശരീരം പ്രവർത്തനത്തിന്റെ:

(defn name [params] ശരീരം)

പാരാമീറ്ററുകൾക്ക് മുന്നിൽ ഇനിപ്പറയുന്ന കീവേഡുകൾ ഉണ്ടായിരിക്കാം:

&ഓപ്ഷണൽ
പാരാമീറ്റർ ഓപ്ഷണൽ ആണ്. പരാമീറ്റർ രണ്ട് ഇനങ്ങളുടെ പട്ടികയായി നൽകാം, ഇവിടെ
ആദ്യ ഘടകം പരാമീറ്റർ നാമവും രണ്ടാമത്തേത് സ്ഥിര മൂല്യവുമാണ്. പരാമീറ്റർ
ഒരൊറ്റ ഇനമായും നൽകാം, ഈ സാഹചര്യത്തിൽ ഡിഫോൾട്ട് മൂല്യം ഒന്നുമില്ല.

=> (defn total-value [മൂല്യം & ഓപ്ഷണൽ [മൂല്യം-വർദ്ധിത-നികുതി 10]]
... (+ (/ (* മൂല്യവർദ്ധിത-നികുതി) 100) മൂല്യം))

=> (മൊത്തം മൂല്യം 100)
110.0

=> (മൊത്തം മൂല്യം 100 1)
101.0

&കീ

&kwargs
പാരാമീറ്ററിൽ 0 അല്ലെങ്കിൽ അതിൽ കൂടുതൽ കീവേഡ് ആർഗ്യുമെന്റുകൾ അടങ്ങിയിരിക്കും.

ഇനിപ്പറയുന്ന കോഡ് ഉദാഹരണങ്ങൾ എല്ലാ കീവേഡുകളും പ്രിന്റ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു
വാദങ്ങളും അവയുടെ മൂല്യങ്ങളും.

=> (defn print-parameters [&kwargs kwargs]
... ([(, kv) (.ഇനങ്ങൾ kwargs)] (kv പ്രിന്റ് ചെയ്യുക)))

=> (പ്രിന്റ്-പാരാമീറ്ററുകൾ പ്രയോഗിക്കുക [] {"പാരാമീറ്റർ-1" 1 "പാരാമീറ്റർ-2" 2})
പാരാമീറ്റർ-2 2
പാരാമീറ്റർ-1 1

&വിശ്രമിക്കുക പാരാമീറ്ററിൽ 0 അല്ലെങ്കിൽ അതിലധികമോ പൊസിഷണൽ ആർഗ്യുമെന്റുകൾ അടങ്ങിയിരിക്കും. മറ്റൊരു സ്ഥാനവും ഇല്ല
ഇതിന് ശേഷം വാദങ്ങൾ വ്യക്തമാക്കാം.

ഇനിപ്പറയുന്ന കോഡ് ഉദാഹരണം 0 മുതൽ n വരെ സംഖ്യകൾ നൽകാവുന്ന ഒരു ഫംഗ്‌ഷനെ നിർവചിക്കുന്നു
പരാമീറ്ററുകൾ. അത് പിന്നീട് ഓരോ ഒറ്റ സംഖ്യയും സംഗ്രഹിക്കുകയും എല്ലാ ഇരട്ട സംഖ്യകളും കുറയ്ക്കുകയും ചെയ്യുന്നു.

=> (ഡിഫൻ സിഗ്-സാഗ്-സം [&ബാക്കി നമ്പറുകൾ]
(ഒറ്റ-സംഖ്യകൾ (ലിസ്റ്റ്-കോമ്പ് x [x നമ്പറുകൾ] (ഒറ്റം? x))]
[ഇരട്ട-സംഖ്യകൾ (ലിസ്റ്റ്-കോമ്പ് x [x നമ്പറുകൾ] (പോലും? x))]]
(- (ഒറ്റ-സംഖ്യകൾ) (തുക ഇരട്ട സംഖ്യകൾ)))

=> (zig-zag-sum)
0
=> (zig-zag-sum 3 9 4)
8
=> (zig-zag-sum 1 2 3 4 5 6)
-3

defn-അപരനാമം / defun-alias
0.10.0 പതിപ്പിൽ പുതിയത്.

ദി defn-അപരനാമം ഒപ്പം defun-alias മാക്രോകൾ വളരെ സമാനമാണ് defn, എന്ന വ്യതിരിക്തതയോടെ
ഒരൊറ്റ പേരിൽ ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നതിനുപകരം, ഇവയ്ക്ക് അപരനാമങ്ങളും നിർവചിക്കാം. മറ്റുള്ളവ
ഫംഗ്‌ഷൻ പേരുകൾക്കുള്ള ചിഹ്നങ്ങളുടെ ഒരു ലിസ്റ്റ് ആദ്യ പാരാമീറ്ററായി എടുക്കുന്നതിനേക്കാൾ, defn-അപരനാമം ഒപ്പം
defun-alias എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമല്ല defn ഒപ്പം defun.

=> (defn-alias [പ്രധാന-നാമം അപരനാമം] []
... ("ഹലോ!" അച്ചടിക്കുക))
=> (പ്രധാന നാമം)
"ഹലോ!"
=> (അപരനാമം)
"ഹലോ!"

defmain
0.10.1 പതിപ്പിൽ പുതിയത്.

ദി defmain മാക്രോ ഒരു പ്രധാന പ്രവർത്തനത്തെ നിർവചിക്കുന്നു, അത് ഉടനടി വിളിക്കുന്നു sys.argv as
ഈ ഫയൽ ഒരു സ്ക്രിപ്റ്റായി എക്സിക്യൂട്ട് ചെയ്യുകയാണെങ്കിൽ മാത്രം ആർഗ്യുമെന്റുകൾ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇത്:

(defmain [&rest args]
(ആർഗ്സ് ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക))

ഇതിന് തുല്യമാണ്:

പ്രധാനം (*ആർഗ്സ്):
(ആർഗ്സ്) ഉപയോഗിച്ച്_എന്തെങ്കിലും_ചെയ്യുക
മടങ്ങുക 0

__പേര്__ == "__പ്രധാന__":
sys ഇംപോർട്ട് ചെയ്യുക
retval = പ്രധാന (*sys.arg)

ഇൻസ്‌റ്റൻസ് (retval, int):
sys.exit(retval)

നിങ്ങൾക്ക് മുകളിൽ കാണുന്നത് പോലെ, ഈ ഫംഗ്‌ഷനിൽ നിന്ന് ഒരു പൂർണ്ണസംഖ്യ നൽകുകയാണെങ്കിൽ, ഇത് ഇതായിരിക്കും
നിങ്ങളുടെ സ്ക്രിപ്റ്റിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസായി ഉപയോഗിച്ചു. (അല്ലെങ്കിൽ സ്റ്റാറ്റസ് 0-ൽ നിന്ന് പുറത്തുകടക്കാൻ പൈത്തൺ ഡിഫോൾട്ട് ചെയ്യുന്നു,
അതിനർത്ഥം എല്ലാം ശരിയാണ്!)

(മുതലുള്ള (sys.exit 0) പൂർണ്ണസംഖ്യയല്ലാത്ത റിട്ടേണിന്റെ കാര്യത്തിൽ ഇത് വ്യക്തമായി പ്രവർത്തിക്കില്ല
defmain, ഇടുന്നത് നല്ലതാണ് (defmain) നിങ്ങളുടെ ഫയലിലെ അവസാന കോഡായി.)

defmacro
defmacro മാക്രോകൾ നിർവചിക്കാൻ ഉപയോഗിക്കുന്നു. പൊതുവായ ഫോർമാറ്റ് ആണ് (defmacro പേര് [പാരാമീറ്ററുകൾ]
എക്സ്പിആർ).

കോഡിലെ മൂലകങ്ങളുടെ ക്രമം മാറ്റാൻ ഉപയോഗിക്കാവുന്ന ഒരു മാക്രോയെ ഇനിപ്പറയുന്ന ഉദാഹരണം നിർവചിക്കുന്നു,
ഇൻഫിക്സ് നൊട്ടേഷനിൽ കോഡ് എഴുതാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്നു, അവിടെ ഓപ്പറേറ്റർ ഇതിനിടയിലാണ്
പ്രവർത്തനങ്ങൾ.

=> (defmacro infix [കോഡ്]
... (അർദ്ധ ഉദ്ധരണി (
... (ഉദ്ധരിക്കുക (കോഡ് 1 നേടുക))
... (ഉദ്ധരിക്കുക (കോഡ് 0 നേടുക))
... (ഉദ്ധരിക്കുക (കോഡ് 2 നേടുക)))))

=> (ഇൻഫിക്സ് (1 + 1))
2

defmacro-അപരനാമം
defmacro-അപരനാമം ഒന്നിലധികം പേരുകളുള്ള (അപരനാമങ്ങൾ) മാക്രോകളെ നിർവചിക്കാൻ ഉപയോഗിക്കുന്നു. പൊതു ഫോർമാറ്റ്
is (defmacro-alias [പേരുകൾ] [പാരാമീറ്ററുകൾ] എക്സ്പിആർ). ഇത് ഒന്നിലധികം മാക്രോകൾ സൃഷ്ടിക്കുന്നു
പേരുകളുടെ നിർദ്ദിഷ്ട ലിസ്റ്റിന് കീഴിലുള്ള പാരാമീറ്റർ ലിസ്റ്റും ബോഡിയും.

ഇനിപ്പറയുന്ന ഉദാഹരണം രണ്ട് മാക്രോകളെ നിർവചിക്കുന്നു, ഇവ രണ്ടും ഉപയോക്താവിനെ കോഡ് എഴുതാൻ അനുവദിക്കുന്നു
infix നൊട്ടേഷൻ.

=> (defmacro-alias [infix infi] [കോഡ്]
... (അർദ്ധ ഉദ്ധരണി (
... (ഉദ്ധരിക്കുക (കോഡ് 1 നേടുക))
... (ഉദ്ധരിക്കുക (കോഡ് 0 നേടുക))
... (ഉദ്ധരിക്കുക (കോഡ് 2 നേടുക)))))

=> (ഇൻഫിക്സ് (1 + 1))
2
=> (infi (1 + 1))
2

defmacro/g!
0.9.12 പതിപ്പിൽ പുതിയത്.

defmacro/g! യുടെ ഒരു പ്രത്യേക പതിപ്പാണ് defmacro അത് സ്വയമേവ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു gensym
ആരംഭിക്കുന്ന ഏത് ചിഹ്നത്തിനും g!.

ഉദാഹരണത്തിന്, g!a ആകും (ജെൻസിം "എ").

കാണുക കൂടാതെ:
ജെൻസിം ഉപയോഗിക്കുന്ന വിഭാഗം

defreader
0.9.12 പതിപ്പിൽ പുതിയത്.

defreader ഒരു റീഡർ മാക്രോ നിർവചിക്കുന്നു, വാക്യഘടന പുനഃക്രമീകരിക്കാനോ പരിഷ്ക്കരിക്കാനോ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു.

=> (defreader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1)
=> #^"ഹലോ"
"ഹലോ"

കാണുക കൂടാതെ:
വിഭാഗം റീഡർ മാക്രോകൾ

Del
0.9.12 പതിപ്പിൽ പുതിയത്.

Del നിലവിലെ നെയിംസ്പേസിൽ നിന്ന് ഒരു വസ്തുവിനെ നീക്കം ചെയ്യുന്നു.

=> (setv foo 42)
=> (ഡെൽ ഫൂ)
=> foo
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
ഫയൽ " ", വരി 1, ഇൻ
NameError: പേര് 'foo' നിർവചിച്ചിട്ടില്ല

Del മാപ്പിംഗുകൾ, ലിസ്‌റ്റുകൾ എന്നിവയിൽ നിന്നും മറ്റും ഒബ്‌ജക്‌റ്റുകൾ നീക്കം ചെയ്യാനും കഴിയും.

=> (setv ടെസ്റ്റ് (ലിസ്റ്റ് (പരിധി 10)))
=> ടെസ്റ്റ്
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (ഡെൽ (സ്ലൈസ് ടെസ്റ്റ് 2 4)) ;; ഒഴിവാക്കിയ 2 മുതൽ 4 വരെയുള്ള ഇനങ്ങൾ നീക്കം ചെയ്യുക
=> ടെസ്റ്റ്
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> ഡിസി
{"foo": "ബാർ"}
=> (ഡെൽ (ഡിക് "ഫൂ" നേടുക))
=> ഡിസി
{}

ഡോട്ടോ
0.10.1 പതിപ്പിൽ പുതിയത്.

ഡോട്ടോ ഒരു ഒബ്‌ജക്‌റ്റിലേക്കുള്ള മെത്തേഡ് കോളുകളുടെ ഒരു ക്രമം ലളിതമാക്കാൻ ഉപയോഗിക്കുന്നു.

=> (doto [] (.അനുബന്ധം 1) (.അനുബന്ധം 2) .റിവേഴ്സ്)
[2 1]

=> (setv ശേഖരം [])
=> (.ശേഖരം 1 കൂട്ടിച്ചേർക്കുക)
=> (.ശേഖരം 2 കൂട്ടിച്ചേർക്കുക)
=> (.റിവേഴ്സ് കളക്ഷൻ)
=> ശേഖരം
[2 1]

പരിണാമം
പരിണാമം ഉദ്ധരിച്ച ഒരു പദപ്രയോഗം വിലയിരുത്തുകയും മൂല്യം നൽകുകയും ചെയ്യുന്നു.

=> (eval '("ഹലോ വേൾഡ്" അച്ചടിക്കുക))
"ഹലോ വേൾഡ്"

eval-and-compile
എവൽ-എപ്പോൾ-കംപൈൽ
ആദ്യം / കാര്
ആദ്യം ഒപ്പം കാര് ഒരു ശേഖരത്തിന്റെ ആദ്യ ഘടകം ആക്‌സസ് ചെയ്യുന്നതിനുള്ള മാക്രോകളാണ്:

=> (ആദ്യം (പരിധി 10))
0

വേണ്ടി
വേണ്ടി ഒരു ലിസ്റ്റിലോ വെക്‌ടറിലോ ഉള്ള ഓരോ ഘടകത്തിനും ഒരു ഫംഗ്‌ഷൻ വിളിക്കാൻ ഉപയോഗിക്കുന്നു. ഓരോന്നിന്റെയും ഫലങ്ങൾ
കോൾ നിരസിക്കപ്പെട്ടു വേണ്ടി എക്സ്പ്രഷൻ തിരിച്ചുവരുന്നു ഒന്നുമില്ല പകരം. ഉദാഹരണ കോഡ് ആവർത്തിക്കുന്നു
മേൽ സമാഹാരം ഓരോന്നിനും മൂലകം in സമാഹാരം വിളിക്കുന്നു പാർശ്വഫലം ഉപയോഗിച്ച് പ്രവർത്തിക്കുക
മൂലകം അതിന്റെ വാദം പോലെ:

;; (പാർശ്വഫലം) ഒരൊറ്റ പരാമീറ്റർ എടുക്കുന്ന ഒരു ഫംഗ്‌ഷനാണെന്ന് അനുമാനിക്കുന്നു
([ഘടക ശേഖരണത്തിന്] (പാർശ്വഫല മൂലകം))

;; എന്നതിന് ഒരു ഓപ്ഷണൽ മറ്റെന്തെങ്കിലും ബ്ലോക്ക് ഉണ്ടായിരിക്കാം
([മൂലക ശേഖരണത്തിന്] (പാർശ്വഫല മൂലകം)
(മറ്റൊരു (പാർശ്വഫലം-2)))

ഓപ്ഷണൽ മറ്റാരെങ്കിലും എങ്കിൽ മാത്രമേ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യൂ വേണ്ടി ലൂപ്പ് സാധാരണയായി അവസാനിക്കുന്നു. എങ്കിൽ
ഉപയോഗിച്ച് നിർവ്വഹണം നിർത്തി ഇടവേള, മറ്റാരെങ്കിലും ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നില്ല.

=> ([1 2 3]] എന്നതിന് ((< ഘടകം 3)
... (അച്ചടി ഘടകം)
... (ബ്രേക്ക്))
... (മറ്റൊരു ("ലൂപ്പ് ഫിനിഷ്" എന്ന് അച്ചടിക്കുക)))
1
2

=> ([1 2 3]] എന്നതിന് ((< ഘടകം 4)
... (അച്ചടി ഘടകം)
... (ബ്രേക്ക്))
... (മറ്റൊരു ("ലൂപ്പ് ഫിനിഷ്" എന്ന് അച്ചടിക്കുക)))
1
2
3
ലൂപ്പ് പൂർത്തിയായി

genexpr
genexpr ജനറേറ്റർ എക്സ്പ്രഷനുകൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. ഇതിന് രണ്ടോ മൂന്നോ പാരാമീറ്ററുകൾ ആവശ്യമാണ്. ദി
ആദ്യ പാരാമീറ്റർ റിട്ടേൺ മൂല്യത്തെ നിയന്ത്രിക്കുന്ന എക്സ്പ്രഷനാണ്, രണ്ടാമത്തേത് ഉപയോഗിക്കുന്നു
ഒരു ലിസ്റ്റിൽ നിന്ന് ഇനങ്ങൾ തിരഞ്ഞെടുക്കാൻ. മൂന്നാമത്തേതും ഓപ്ഷണൽ പരാമീറ്ററും ഫിൽട്ടർ ചെയ്യാൻ ഉപയോഗിക്കാം
ഒരു സോപാധിക പദപ്രയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ള ലിസ്റ്റിലെ ചില ഇനങ്ങൾ. genexpr സമാനമാണ്
ലിസ്റ്റ്-കോം, അതിനുപകരം മൂല്യങ്ങൾ ഓരോന്നായി മൂല്യനിർണ്ണയം ചെയ്യുന്ന ഒരു ഐറ്ററബിൾ നൽകുന്നു എന്നതൊഴിച്ചാൽ
അവരെ ഉടനടി വിലയിരുത്തുന്നു.

=> (ഡെഫ് കളക്ഷൻ (പരിധി 10))
=> (ഡെഫ് ഫിൽട്ടർ ചെയ്‌തു (genexpr x [x ശേഖരം] (പോലും? x)))
=> (ലിസ്റ്റ് ഫിൽട്ടർ ചെയ്‌തു)
[0, 2, 4, 6, 8]

gensym
0.9.12 പതിപ്പിൽ പുതിയത്.

gensym മാക്രോകൾ ഇല്ലാതെ എഴുതാൻ അനുവദിക്കുന്ന ഒരു അദ്വിതീയ ചിഹ്നം സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു
ആകസ്മികമായ വേരിയബിൾ നാമം ഏറ്റുമുട്ടുന്നു.

=> (ജെൻസിം)
u':G_1235'

=> (ജെൻസിം "x")
u':x_1236'

കാണുക കൂടാതെ:
ജെൻസിം ഉപയോഗിക്കുന്ന വിഭാഗം

നേടുക
നേടുക ലിസ്റ്റുകളിലും നിഘണ്ടുക്കളിലും ഒറ്റ ഘടകങ്ങൾ ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. നേടുക രണ്ട് പാരാമീറ്ററുകൾ എടുക്കുന്നു:
The ഡാറ്റ ഘടന ഒപ്പം സൂചിക or കീ ഇനത്തിന്റെ. അത് പിന്നീട് ബന്ധപ്പെട്ടത് തിരികെ നൽകും
നിഘണ്ടുവിൽ നിന്നോ പട്ടികയിൽ നിന്നോ ഉള്ള മൂല്യം. ഉദാഹരണ ഉപയോഗം:

=> ([[മൃഗങ്ങളെ {"നായ" "കുരയ്ക്കാൻ" "പൂച്ച" "മ്യാവൂ"}]
... [നമ്പറുകൾ ["പൂജ്യം" "ഒന്ന്" "രണ്ട്" "മൂന്ന്"]]]
... (പ്രിന്റ് (മൃഗങ്ങളെ "നായ" നേടുക))
... (അച്ചടിക്കുക (നമ്പറുകൾ 2 നേടുക)))
കുര
രണ്ട്

ശ്രദ്ധിക്കുക:
നേടുക നിലവിലില്ലാത്ത ഒരു കീക്കായി ഒരു നിഘണ്ടു ചോദിച്ചാൽ ഒരു KeyError ഉയർത്തുന്നു.

ശ്രദ്ധിക്കുക:
നേടുക പുറത്തുള്ള ഒരു സൂചികയ്ക്കായി ഒരു ലിസ്‌റ്റോ ട്യൂപ്പിളോ അന്വേഷിച്ചാൽ ഒരു സൂചിക പിശക് ഉയർത്തുന്നു
അതിരുകൾ.

ഗ്ലോബൽ
ഗ്ലോബൽ ഒരു ചിഹ്നത്തെ ആഗോളമായി അടയാളപ്പെടുത്താൻ ഉപയോഗിക്കാം. ഇത് പ്രോഗ്രാമറെ അസൈൻ ചെയ്യാൻ അനുവദിക്കുന്നു
ഒരു ആഗോള ചിഹ്നത്തിലേക്കുള്ള മൂല്യം. ഒരു ആഗോള ചിഹ്നം വായിക്കുന്നത് ആവശ്യമില്ല ഗ്ലോബൽ കീവേഡ് --
അസൈൻ ചെയ്യുന്നത് മാത്രമാണ് ചെയ്യുന്നത്.

ആഗോള ചിഹ്നം എങ്ങനെയെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു a ഒരു ഫംഗ്‌ഷനിൽ ഒരു മൂല്യം നൽകിയിരിക്കുന്നു കൂടാതെ
പിന്നീട് മറ്റൊരു ഫംഗ്‌ഷനിൽ അച്ചടിക്കുന്നു. ഇല്ലാതെ ഗ്ലോബൽ കീവേഡ്, രണ്ടാമത്തെ പ്രവർത്തനം
എ എറിയുമായിരുന്നു പേര് പിശക്.

(defn set-a [മൂല്യം]
(ആഗോള എ)
(ഒരു മൂല്യം സജ്ജമാക്കുക))

(defn print-a []
(പ്രിന്റ് എ))

(സെറ്റ്-എ 5)
(പ്രിന്റ്-എ)

if / അല്ലെങ്കിൽ
0.10.0 പതിപ്പിൽ പുതിയത്: if-not

if എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡ് സോപാധികമായി തിരഞ്ഞെടുക്കാൻ ഉപയോഗിക്കുന്നു. അതിൽ ഒരു വ്യവസ്ഥ അടങ്ങിയിരിക്കണം
ബ്ലോക്കും, കണ്ടീഷൻ ബ്ലോക്ക് വിലയിരുത്തിയാൽ എക്സിക്യൂട്ട് ചെയ്യേണ്ട ബ്ലോക്കും ട്രൂ. ഓപ്ഷണലായി,
വ്യവസ്ഥയുടെ മൂല്യനിർണ്ണയം ഉണ്ടെങ്കിൽ അത് നടപ്പിലാക്കുന്ന ഒരു അന്തിമ ബ്ലോക്ക് അടങ്ങിയിരിക്കാം
തെറ്റായ.

അല്ലെങ്കിൽ സമാനമാണ്, എന്നാൽ അവസ്ഥ പരാജയപ്പെടുമ്പോൾ രണ്ടാമത്തെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും
ടെസ്റ്റ് വിജയിക്കുമ്പോൾ മൂന്നാമത്തേതും അവസാനത്തേതുമായ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും -- വിപരീത ക്രമം if.

ഉദാഹരണ ഉപയോഗം:

(എങ്കിൽ (പണം അവശേഷിക്കുന്നുണ്ടോ? അക്കൗണ്ട്)
("നമുക്ക് ഷോപ്പിംഗിന് പോകാം" എന്ന് അച്ചടിക്കുക)
("നമുക്ക് പോയി പ്രവർത്തിക്കാം" എന്ന് അച്ചടിക്കുക))

(ഇല്ലെങ്കിൽ (പണം ബാക്കി? അക്കൗണ്ട്)
("നമുക്ക് പോയി പ്രവർത്തിക്കാം" എന്ന് അച്ചടിക്കുക)
("നമുക്ക് ഷോപ്പിംഗിന് പോകാം" എന്ന് അച്ചടിക്കുക))

പൈത്തൺ സത്യത്തെ ബഹുമാനിക്കുന്നു. ഒന്നുമില്ല, തെറ്റായ, ഏതെങ്കിലും സംഖ്യാ തരത്തിന്റെ പൂജ്യം, ഒരു ശൂന്യമായ ക്രമം,
കൂടാതെ ഒരു ശൂന്യമായ നിഘണ്ടു പരിഗണിക്കും തെറ്റായ; മറ്റെല്ലാം പരിഗണിക്കപ്പെടുന്നു ട്രൂ.

lisp-if / നാര് ഒപ്പം lisp-if-ഇല്ലെങ്കിൽ / ലിഫ്-അല്ല
0.10.0 പതിപ്പിൽ പുതിയത്.

പതിപ്പ് 0.10.2-ൽ പുതിയത്: lisp-if-not / lip-not

കൂടുതൽ ലിസ്പി ഇഷ്ടപ്പെടുന്നവർക്ക് if ക്ലോസ്, ഞങ്ങൾക്കുണ്ട് lisp-if, അഥവാ നാര്. ഈ മാത്രം പരിഗണിക്കുന്നു
ഒന്നുമില്ല / ഇല്ല കള്ളം! മറ്റെല്ലാ "തെറ്റായ" പൈത്തൺ മൂല്യങ്ങളും ശരിയാണെന്ന് കണക്കാക്കുന്നു.
നേരെമറിച്ച്, നമുക്കുണ്ട് lisp-if-ഇല്ലെങ്കിൽ ഒപ്പം ലിഫ്-അല്ല സമാന്തരമായി if ഒപ്പം അല്ലെങ്കിൽ ഏത് വിപരീതമാക്കുന്നു
താരതമ്യം.

=> (lisp-If True "true" "false")
"true"
=> (lisp-False "true" "false")
"true"
=> (lisp-if 0 "true" "false")
"true"
=> (lisp-if nil "true" "false")
"തെറ്റായ"
=> (lisp-ഒന്നും "ശരി" "തെറ്റ്" ഇല്ലെങ്കിൽ)
"തെറ്റായ"
=> (lisp-if-not nil "true" "false")
"true"
=> (lisp-if-not None "true" "false")
"true"
=> (lisp-if-not False "true" "false")
"തെറ്റായ"

; തുല്യമെങ്കിലും ചെറുതാണ്
=> (ജീവിതം ശരിയാണെങ്കിൽ "ശരി" "തെറ്റ്")
"true"
=> (ജീവിതം ഇല്ല "ശരി" "തെറ്റ്")
"തെറ്റായ"
=> (ലിഫ്-അല്ല ഒന്നുമല്ല "സത്യം" "തെറ്റ്")
"true"

ഇറക്കുമതി
ഇറക്കുമതി പൈത്തണിലെ പോലെ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യാൻ ഉപയോഗിക്കുന്നു. അതിന് നിരവധി മാർഗങ്ങളുണ്ട് ഇറക്കുമതി കഴിയും
ഉപയോഗിക്കും.

;; ഈ മൊഡ്യൂളുകൾ ഓരോന്നും ഇറക്കുമതി ചെയ്യുന്നു
;;
;; പൈത്തൺ:
;; ഇറക്കുമതി sys
;; os.path ഇറക്കുമതി ചെയ്യുക
(sys os.path ഇറക്കുമതി ചെയ്യുക)

;; ഒരു മൊഡ്യൂളിൽ നിന്ന് ഇറക്കുമതി ചെയ്യുക
;;
;; പൈത്തൺ: os.path-ൽ നിന്ന് ഇറക്കുമതി നിലവിലുണ്ട്, isdir, isfile
(ഇറക്കുമതി [os.path [isdir isfile നിലവിലുണ്ട്]])

;; ഒരു അപരനാമം ഉപയോഗിച്ച് ഇറക്കുമതി ചെയ്യുക
;;
;; പൈത്തൺ: സിസ്റ്റെസ്റ്റായി സിസ് ഇറക്കുമതി ചെയ്യുക
(ഇറക്കുമതി [sys:systest])

;; വ്യത്യസ്‌ത തരത്തിൽ നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര ഇറക്കുമതികൾ ലിസ്റ്റ് ചെയ്യാം.
(ഇറക്കുമതി [tests.resources [kwtest function-with-a-dash]]
[os.path [isdir isfile നിലവിലുണ്ട്]]
[സിസ്: സിസ്റ്റസ്റ്റായി])

;; നിലവിലെ നെയിംസ്‌പെയ്‌സിലേക്ക് എല്ലാ മൊഡ്യൂൾ ഫംഗ്‌ഷനുകളും ഇറക്കുമതി ചെയ്യുക
(ഇറക്കുമതി [sys [*]])

ലാംഡ / fn
ലാംഡ ഒപ്പം fn ഒരു അജ്ഞാത ഫംഗ്ഷൻ നിർവചിക്കാൻ ഉപയോഗിക്കാം. പരാമീറ്ററുകൾ സമാനമാണ്
defn: ആദ്യത്തെ പാരാമീറ്റർ പാരാമീറ്ററുകളുടെ വെക്റ്റർ ആണ്, ബാക്കിയുള്ളത് അതിന്റെ ബോഡിയാണ്
പ്രവർത്തനം. ലാംഡ ഒരു പുതിയ ഫംഗ്‌ഷൻ നൽകുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ഒരു അജ്ഞാത പ്രവർത്തനം
നിർവചിക്കുകയും ഔട്ട്‌പുട്ട് ഫിൽട്ടർ ചെയ്യുന്നതിനായി മറ്റൊരു ഫംഗ്‌ഷനിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു.

=> (ഡെഫ് ആളുകൾ [{:name "Alice" :age 20}
... {:പേര് "ബോബ്" :വയസ്സ് 25}
... {:പേര് "ചാർലി" :വയസ്സ് 50}
... {:പേര് "ഡേവ്" :വയസ്സ് 5}])

=> (defn display-people [ആളുകൾ ഫിൽട്ടർ]
... ([വ്യക്തി ആളുകൾക്ക്] ((ഫിൽട്ടർ വ്യക്തി) ആണെങ്കിൽ (: പേര് വ്യക്തി))))

=> (ഡിസ്‌പ്ലേ-ആളുകൾ (fn [വ്യക്തി] (< (:പ്രായക്കാരൻ) 25)))
ആലിസ്
ഡേവ്

സാധാരണ പ്രവർത്തന നിർവചനങ്ങളിലെന്നപോലെ, ശരീരത്തിന്റെ ആദ്യ ഘടകം ഒരു ചരടാണെങ്കിൽ, അത്
ഒരു ഡോക്‌ട്രിംഗ് ആയി പ്രവർത്തിക്കുന്നു. ക്ലാസ് രീതികളുടെ ഡോക്‌സ്‌ട്രിംഗുകൾ നൽകാൻ ഇത് ഉപയോഗപ്രദമാണ്.

=> (setv തവണ-മൂന്ന്
... (fn [x]
... "ഇൻപുട്ട് മൂന്ന് കൊണ്ട് ഗുണിച്ച് ഫലം നൽകുന്നു."
... (* x 3)))

പൈത്തണിന്റെ ബിൽറ്റ്-ഇൻ വഴി ഇത് സ്ഥിരീകരിക്കാൻ കഴിയും സഹായിക്കൂ പ്രവർത്തനം:

=> (സഹായം തവണ-മൂന്ന്)
പ്രവർത്തന സമയങ്ങളിൽ സഹായം_മൂന്ന്:

തവണ_മൂന്ന്(x)
ഇൻപുട്ടിനെ മൂന്നായി ഗുണിച്ച് ഫലം നൽകുന്നു
(അവസാനിക്കുന്നു)

അവസാനത്തെ
0.10.2 പതിപ്പിൽ പുതിയത്.

അവസാനത്തെ ഒരു ശേഖരത്തിന്റെ അവസാന ഘടകം ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കാം:

=> (അവസാനം [2 4 6])
6

ചെയ്യട്ടെ
ചെയ്യട്ടെ ലെക്സിക്കലി സ്കോപ്പ്ഡ് വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. ന്റെ തുടക്കത്തിൽ അവ സൃഷ്ടിക്കപ്പെടുന്നു
ചെയ്യട്ടെ രൂപത്തിനു ശേഷം രൂപപ്പെടുകയും ഇല്ലാതാകുകയും ചെയ്യുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണം ഇത് കാണിക്കുന്നു
പെരുമാറ്റം:

=> (ആവട്ടെ [[x 5]] (x പ്രിന്റ് ചെയ്യുക)
... (ആവട്ടെ [[x 6]] (x പ്രിന്റ് ചെയ്യുക))
... (x പ്രിന്റ് ചെയ്യുക))
5
6
5

ദി ചെയ്യട്ടെ മാക്രോ രണ്ട് പാരാമീറ്ററുകൾ എടുക്കുന്നു: ഒരു വെക്റ്റർ നിർവചിക്കുന്നു വേരിയബിളുകൾ ഒപ്പം ശരീരം ലഭിക്കുന്നത്
നടപ്പിലാക്കി. വേരിയബിളുകൾ ഓരോ മൂലകവും ഒരൊറ്റ വേരിയബിളോ വെക്‌ടറോ ആയ വെക്‌ടറാണ്
ഒരു വേരിയബിൾ മൂല്യ ജോഡി നിർവചിക്കുന്നു. ഒരൊറ്റ വേരിയബിളിന്റെ കാര്യത്തിൽ, അതിന് മൂല്യം നൽകിയിരിക്കുന്നു
ഒന്നുമില്ല; അല്ലെങ്കിൽ, നൽകിയ മൂല്യം ഉപയോഗിക്കുന്നു.

=> (ആവട്ടെ [x [y 5]] (xy പ്രിന്റ് ചെയ്യുക))
ഒന്നുമില്ല 5

ലിസ്റ്റ്-കോം
ലിസ്റ്റ്-കോം ലിസ്റ്റ് ധാരണകൾ നിർവഹിക്കുന്നു. ഇതിന് രണ്ടോ മൂന്നോ പാരാമീറ്ററുകൾ ആവശ്യമാണ്. ആദ്യത്തേത്
പാരാമീറ്റർ എന്നത് റിട്ടേൺ മൂല്യത്തെ നിയന്ത്രിക്കുന്ന എക്സ്പ്രഷനാണ്, രണ്ടാമത്തേത് ഉപയോഗിക്കുമ്പോൾ
ഒരു ലിസ്റ്റിൽ നിന്ന് ഇനങ്ങൾ തിരഞ്ഞെടുക്കുക. ചിലത് ഫിൽട്ടർ ചെയ്യാൻ മൂന്നാമത്തേതും ഓപ്ഷണൽ പരാമീറ്ററും ഉപയോഗിക്കാം
ഒരു സോപാധിക പദപ്രയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ള ലിസ്റ്റിലെ ഇനങ്ങളുടെ. ചില ഉദാഹരണങ്ങൾ:

=> (ഡെഫ് കളക്ഷൻ (പരിധി 10))
=> (list-comp x [x ശേഖരം])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (list-comp (* x 2) [x ശേഖരം])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

=> (list-comp (* x 2) [x ശേഖരം] (< x 5))
[0, 2, 4, 6, 8]

അല്ല
അല്ല ലോജിക്കൽ എക്സ്പ്രഷനുകളിൽ ഉപയോഗിക്കുന്നു. ഇത് ഒരൊറ്റ പാരാമീറ്റർ എടുത്ത് ഒരു റിവേഴ്സ്ഡ് നൽകുന്നു
സത്യ മൂല്യം. എങ്കിൽ ട്രൂ ഒരു പരാമീറ്ററായി നൽകിയിരിക്കുന്നു, തെറ്റായ തിരികെ നൽകും, തിരിച്ചും.
ഉദാഹരണ ഉപയോഗം:

=> (സത്യമല്ല)
തെറ്റായ

=> (തെറ്റല്ല)
ട്രൂ

=> (ഒന്നുമില്ല)
ട്രൂ

or
or ലോജിക്കൽ എക്സ്പ്രഷനുകളിൽ ഉപയോഗിക്കുന്നു. ഇതിന് കുറഞ്ഞത് രണ്ട് പാരാമീറ്ററുകൾ ആവശ്യമാണ്. അത് തിരികെ നൽകും
ആദ്യത്തെ തെറ്റായ പാരാമീറ്റർ. അത്തരമൊരു മൂല്യം നിലവിലില്ലെങ്കിൽ, അവസാന പാരാമീറ്റർ തിരികെ നൽകും.

=> (അല്ലെങ്കിൽ ശരി തെറ്റ്)
ട്രൂ

=> (തെറ്റായ തെറ്റും)
തെറ്റായ

=> (False 1 True False)
1

ശ്രദ്ധിക്കുക:
or ഷോർട്ട് സർക്യൂട്ടുകളും ആദ്യത്തെ യഥാർത്ഥ മൂല്യം ആയ ഉടൻ തന്നെ പാരാമീറ്ററുകൾ വിലയിരുത്തുന്നത് നിർത്തുന്നു
നേരിട്ടു.

=> (അല്ലെങ്കിൽ ശരി ("ഹലോ" എന്ന് അച്ചടിക്കുക))
ട്രൂ

അച്ചടിക്കുക
അച്ചടിക്കുക സ്ക്രീനിൽ ഔട്ട്പുട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഉദാഹരണ ഉപയോഗം:

("ഹലോ വേൾഡ്!" അച്ചടിക്കുക)

ശ്രദ്ധിക്കുക:
അച്ചടിക്കുക എപ്പോഴും മടങ്ങുന്നു ഒന്നുമില്ല.

അർദ്ധ ഉദ്ധരണി
അർദ്ധ ഉദ്ധരണി ഒരു ഫോം ഉദ്ധരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, മാത്രമല്ല എക്സ്പ്രഷനുകൾ തിരഞ്ഞെടുത്ത് വിലയിരുത്തുകയും ചെയ്യുന്നു.
ഉള്ളിലെ ഭാവങ്ങൾ a അർദ്ധ ഉദ്ധരണി ഉപയോഗിച്ച് തിരഞ്ഞെടുത്ത് വിലയിരുത്താം ഉദ്ധരിക്കുക (~). എസ്
മൂല്യനിർണ്ണയ ഫോമും ഉപയോഗിച്ച് വിഭജിക്കാം unquote-spice (~@). ക്വാസിക്വോട്ടും ആകാം
ബാക്ക്ക്വോട്ട് ഉപയോഗിച്ച് എഴുതിയത് (`) ചിഹ്നം.

;; 'qux' മൂല്യമുള്ള ഒരു വേരിയബിളായിരിക്കട്ടെ (ബാർ ബാസ്)
`(foo ~qux)
; '(foo (ബാർ ബാസ്)) ന് തുല്യമാണ്
`(foo ~@qux)
; '(ഫൂ ബാർ ബാസ്) എന്നതിന് തുല്യമാണ്

ഉദ്ധരിക്കുക
ഉദ്ധരിക്കുക അത് മൂല്യനിർണ്ണയം ചെയ്യാതെ അതിലേക്ക് കൈമാറിയ ഫോം തിരികെ നൽകുന്നു. ഉദ്ധരിക്കുക പകരമായി ആകാം
അപ്പോസ്‌ട്രോഫി ഉപയോഗിച്ച് എഴുതിയത് (') ചിഹ്നം.

=> (setv x '("ഹലോ വേൾഡ്" അച്ചടിക്കുക))
; വേരിയബിൾ x എക്സ്പ്രഷനിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു & മൂല്യനിർണ്ണയം ചെയ്തിട്ടില്ല
=> x
(u'print' u'Hello World')
=> (eval x)
ഹലോ വേൾഡ്

ആവശ്യമുണ്ട്
ആവശ്യമുണ്ട് നൽകിയിരിക്കുന്ന മൊഡ്യൂളിൽ നിന്ന് മാക്രോകൾ ഇറക്കുമതി ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഇതിന് കുറഞ്ഞത് ഒരു പാരാമീറ്ററെങ്കിലും എടുക്കും
മാക്രോകൾ ഇറക്കുമതി ചെയ്യേണ്ട മൊഡ്യൂൾ വ്യക്തമാക്കുന്നു. ഒന്നിലധികം മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യാൻ കഴിയും
ഒരൊറ്റ ഉപയോഗിച്ച് ആവശ്യമുണ്ട്.

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ നിന്ന് മാക്രോകൾ ഇറക്കുമതി ചെയ്യും മൊഡ്യൂൾ-1 ഒപ്പം മൊഡ്യൂൾ-2:

(മൊഡ്യൂൾ-1 മൊഡ്യൂൾ-2 ആവശ്യമാണ്)

വിശ്രമം / സിഡിആർ
വിശ്രമം ഒപ്പം സിഡിആർ ആദ്യ ഘടകമില്ലാതെ ഒരു ആർഗ്യുമെന്റായി പാസാക്കിയ ശേഖരം തിരികെ നൽകുക:

=> (വിശ്രമം (പരിധി 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

സെറ്റ്-കോമ്പ്
സെറ്റ്-കോമ്പ് സെറ്റുകൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. ഇതിന് രണ്ടോ മൂന്നോ പാരാമീറ്ററുകൾ ആവശ്യമാണ്. ആദ്യ പാരാമീറ്റർ ആണ്
റിട്ടേൺ മൂല്യം നിയന്ത്രിക്കുന്നതിന്, രണ്ടാമത്തേത് എയിൽ നിന്ന് ഇനങ്ങൾ തിരഞ്ഞെടുക്കാൻ ഉപയോഗിക്കുന്നു
ക്രമം. മൂന്നാമത്തേതും ഓപ്ഷണൽ ആയതുമായ പാരാമീറ്റർ ചില ഇനങ്ങൾ ഫിൽട്ടർ ചെയ്യാൻ ഉപയോഗിക്കാം
ഒരു സോപാധിക പദപ്രയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ള ക്രമം.

=> (setv ഡാറ്റ [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x ഡാറ്റ] (ഒറ്റ? x))
{1, 3, 5}

സ്ലൈസ്
സ്ലൈസ് ഒരു ലിസ്റ്റിന്റെ ഒരു ഉപവിഭാഗം എടുക്കാനും അതിൽ നിന്ന് ഒരു പുതിയ ലിസ്റ്റ് സൃഷ്ടിക്കാനും ഉപയോഗിക്കാം. രൂപം
സ്ലൈസ് ചെയ്യാൻ ലിസ്റ്റ് വ്യക്തമാക്കുന്ന ഒരു പാരാമീറ്ററെങ്കിലും എടുക്കുന്നു. രണ്ട് ഓപ്ഷണൽ പാരാമീറ്ററുകൾ ആകാം
ഉപഗണത്തിന്റെ ആരംഭ, അവസാന സ്ഥാനം നൽകാൻ ഉപയോഗിക്കുന്നു. അവ വിതരണം ചെയ്തില്ലെങ്കിൽ,
സ്ഥിര മൂല്യം ഒന്നുമില്ല പകരം ഉപയോഗിക്കും. മൂന്നാമത്തെ ഓപ്ഷണൽ പാരാമീറ്റർ ഉപയോഗിക്കുന്നു
ഘടകങ്ങൾ തമ്മിലുള്ള നിയന്ത്രണ ഘട്ടം.

സ്ലൈസ് പൈത്തൺ എതിരാളിയുടെ അതേ നിയമങ്ങൾ പിന്തുടരുന്നു. നെഗറ്റീവ് സൂചികകൾ കണക്കാക്കുന്നു
പട്ടികയുടെ അവസാനം മുതൽ ആരംഭിക്കുന്നു. ചില ഉദാഹരണ ഉപയോഗം:

=> (ഡെഫ് കളക്ഷൻ (പരിധി 10))

=> (സ്ലൈസ് ശേഖരണം)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (സ്ലൈസ് ശേഖരം 5)
[5, 6, 7, 8, 9]

=> (സ്ലൈസ് ശേഖരണം 2 8)
[2, 3, 4, 5, 6, 7]

=> (സ്ലൈസ് ശേഖരണം 2 8 2)
[XXX, 2, 4]

=> (സ്ലൈസ് ശേഖരണം -4 -2)
[6, 7]

എറിയുക / ഉളവാക്കുവാൻ
ദി എറിയുക or ഉളവാക്കുവാൻ ഒരു ഉയർത്താൻ ഫോമുകൾ ഉപയോഗിക്കാം ഒഴിവാക്കൽ റൺടൈമിൽ. ഉദാഹരണ ഉപയോഗം:

(എറിയുക)
; അവസാനത്തെ ഒഴിവാക്കൽ വീണ്ടും ഉയർത്തുക

(IOError എറിയുക)
; ഒരു IOError എറിയുക

(എറിയുക (IOError "foobar"))
; ഒരു IOError ("foobar") എറിയുക

എറിയുക ഒരൊറ്റ വാദം അംഗീകരിക്കാൻ കഴിയും (an ഒഴിവാക്കൽ ക്ലാസ് അല്ലെങ്കിൽ ഉദാഹരണം) അല്ലെങ്കിൽ വാദങ്ങളൊന്നുമില്ല
അവസാനത്തേത് വീണ്ടും ഉയർത്തുക ഒഴിവാക്കൽ.

ശ്രമിക്കൂ
ദി ശ്രമിക്കൂ a ആരംഭിക്കാൻ ഫോം ഉപയോഗിക്കുന്നു ശ്രമിക്കൂ / പിടിക്കുക തടയുക. ഫോം ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിക്കുന്നു:

(ശ്രമിക്കുക
(പിശക് സാധ്യതയുള്ള പ്രവർത്തനം)
([e ZeroDivisionError] പിടിക്കുക ("വിഭജനം പൂജ്യം" എന്ന് അച്ചടിക്കുക))
(മറ്റുള്ളവ ("പിശകുകളൊന്നുമില്ല" എന്ന് അച്ചടിക്കുക))
(അവസാനം ("എല്ലാം ചെയ്തു" എന്ന് അച്ചടിക്കുക)))

ശ്രമിക്കൂ കുറഞ്ഞത് ഒരെണ്ണമെങ്കിലും അടങ്ങിയിരിക്കണം പിടിക്കുക തടയുക, കൂടാതെ ഓപ്ഷണലായി ഒരു ഉൾപ്പെടുത്താം മറ്റാരെങ്കിലും or അവസാനമായി
തടയുക. നിർവ്വഹിക്കുന്ന സമയത്ത് പൊരുത്തപ്പെടുന്ന ക്യാച്ച് ബ്ലോക്ക് ഉപയോഗിച്ച് ഒരു പിശക് ഉയർന്നുവന്നാൽ
പിശക് സാധ്യതയുള്ള പ്രവർത്തനം, അത് പിടിക്കുക ബ്ലോക്ക് നടപ്പിലാക്കും. പിശകുകളൊന്നും ഉന്നയിച്ചിട്ടില്ലെങ്കിൽ, മറ്റാരെങ്കിലും
ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ദി അവസാനമായി ബ്ലോക്ക് എന്നത് പരിഗണിക്കാതെ തന്നെ അവസാനമായി നടപ്പിലാക്കും
പിശക് ഉയർന്നു.

അല്ലാതെ
ദി അല്ലാതെ മാക്രോ എന്നത് എഴുതുന്നതിനുള്ള ഒരു ചുരുക്കെഴുത്താണ് if നൽകിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്ന പ്രസ്താവന
വ്യവസ്ഥാപിതമാണ് തെറ്റായ. ഈ മാക്രോയുടെ വികാസം താഴെ കാണിക്കുന്നു.

(സോപാധിക പ്രസ്താവനയല്ലാതെ)

(സോപാധികമെങ്കിൽ
ഒന്നുമില്ല
(പ്രസ്താവന നടത്തുക))

ഉദ്ധരിക്കുക
ഒരു ക്വാസിക്യൂട്ട് ഫോമിൽ, ഉദ്ധരിക്കുക ഒരു ചിഹ്നത്തിന്റെ മൂല്യനിർണ്ണയത്തെ പ്രേരിപ്പിക്കുന്നു. ഉദ്ധരിക്കുക എന്ന അപരനാമത്തിലാണ്
ടിൽഡ് (~) ചിഹ്നം.

(ഡെഫ് നാമം "കഡിൽസ്")
(അർദ്ധ ഉദ്ധരണി (= പേര് (ഉദ്ധരിക്കാത്ത പേര്)))
;=> (u'=' u'name' u'Cuddles')

`(= പേര് ~പേര്)
;=> (u'=' u'name' u'Cuddles')

unquote-spice
unquote-spice ഒരു ചിഹ്നത്തിന്റെ മൂല്യനിർണ്ണയത്തെ ഒരു ക്വാസിക്വോട്ടഡ് രൂപത്തിനുള്ളിൽ നിർബ്ബന്ധിക്കുന്നു
ഉദ്ധരിക്കുക. unquote-spice ഉദ്ധരിക്കാത്ത ചിഹ്നത്തിൽ ഒരു അടങ്ങിയിരിക്കുമ്പോൾ മാത്രമേ ഉപയോഗിക്കാനാകൂ
ആവർത്തിക്കാവുന്ന മൂല്യം, അത് "സ്പ്ലൈസ്" ചെയ്യുന്നതിനാൽ, അത് ക്വാസിക്വോട്ടഡ് രൂപത്തിലേക്ക് ആവർത്തിക്കാം. unquote-spice is
എന്ന അപരനാമം ~@ ചിഹ്നം.

(def സംഖ്യകൾ [1 2 3 4])
(അർദ്ധ ഉദ്ധരണി (+ (ഉദ്ധരിച്ചിട്ടില്ല-സ്പ്ലൈസ് നമ്പറുകൾ)))
;=> (u'+' 1L 2L 3L 4L)

`(+ ~@സംഖ്യകൾ)
;=> (u'+' 1L 2L 3L 4L)

എപ്പോൾ
എപ്പോൾ സമാനമാണ് അല്ലാതെ, നൽകിയിരിക്കുന്ന സോപാധികം എപ്പോഴാണെന്ന് ഇത് പരിശോധിക്കുന്നത് ഒഴികെ ട്രൂ. ഇതല്ല
ഒരു ഉണ്ടായിരിക്കാൻ സാധ്യമാണ് മറ്റാരെങ്കിലും a-ൽ തടയുക എപ്പോൾ മാക്രോ. ഇനിപ്പറയുന്നവയുടെ വികാസം കാണിക്കുന്നു
മാക്രോ.

(സോപാധിക പ്രസ്താവന വരുമ്പോൾ)

(സോപാധികമാണെങ്കിൽ (പ്രസ്താവന ചെയ്യുക))

സമയത്ത്
സമയത്ത് ഒരു വ്യവസ്ഥ പാലിക്കുന്നിടത്തോളം ഒന്നോ അതിലധികമോ ബ്ലോക്കുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഇനിപ്പറയുന്നവ
ഉദാഹരണം "ഹലോ വേൾഡ്!" അനിശ്ചിതമായി സ്ക്രീനിലേക്ക്:

(ശരി ആയിരിക്കുമ്പോൾ ("ഹലോ വേൾഡ്!" അച്ചടിക്കുക))

കൂടെ
കൂടെ ഒരു കോൺടെക്സ്റ്റ് മാനേജറിനുള്ളിൽ ഒരു ബ്ലോക്കിന്റെ നിർവ്വഹണം പൊതിയാൻ ഉപയോഗിക്കുന്നു. സന്ദർഭം
മാനേജർക്ക് പിന്നീട് ലോക്കൽ സിസ്റ്റം സജ്ജീകരിക്കാനും നിയന്ത്രിത രീതിയിൽ പൊളിക്കാനും കഴിയും. ദി
ഉപയോഗിക്കുന്നതിന്റെ ആർക്കൈറ്റിപ്പിക് ഉദാഹരണം കൂടെ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ ആണ്. കൂടെ ഒരു സന്ദർഭം ബന്ധിപ്പിക്കാൻ കഴിയും
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ വാദം അല്ലെങ്കിൽ പൂർണ്ണമായും അവഗണിക്കുക:

([[arg (expr)]] ബ്ലോക്കിനൊപ്പം)

([[(expr)]] ബ്ലോക്കിനൊപ്പം)

([[arg (expr)] [(expr)]] ബ്ലോക്കിനൊപ്പം)

ഇനിപ്പറയുന്ന ഉദാഹരണം തുറക്കും വാർത്തകൾ ഫയൽ ചെയ്ത് അതിന്റെ ഉള്ളടക്കം സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യുക. ദി
ഫയൽ പ്രോസസ്സ് ചെയ്തതിന് ശേഷം സ്വയമേവ അടയുന്നു.

(കൂടെ [[f (ഓപ്പൺ "വാർത്ത")]] (പ്രിന്റ് (.റീഡ് എഫ്)))

കൂടെ-അലങ്കാരകൻ
കൂടെ-അലങ്കാരകൻ ഒരു ഫംഗ്‌ഷൻ മറ്റൊന്നുമായി പൊതിയാൻ ഉപയോഗിക്കുന്നു. നിർവഹിക്കുന്ന പ്രവർത്തനം
അലങ്കാരം ഒരൊറ്റ മൂല്യം സ്വീകരിക്കണം: ഫംഗ്‌ഷൻ അലങ്കരിച്ചിരിക്കുന്നു, പുതിയത് തിരികെ നൽകുക
പ്രവർത്തനം. കൂടെ-അലങ്കാരകൻ കുറഞ്ഞത് രണ്ട് പാരാമീറ്ററുകളെങ്കിലും എടുക്കുന്നു: പ്രവർത്തനം നിർവഹിക്കുന്നു
അലങ്കാരവും ഫംഗ്‌ഷനും അലങ്കരിക്കുന്നു. ഒന്നിലധികം ഡെക്കറേറ്റർ ഫംഗ്‌ഷനുകൾ ആകാം
പ്രയോഗിച്ചു; അവ പുറത്തുനിന്ന് ഉള്ളിലേക്ക് ക്രമത്തിൽ പ്രയോഗിക്കും, അതായത്. ആദ്യത്തേത്
അലങ്കാരപ്പണിക്കാരൻ ഏറ്റവും പുറത്തുള്ളവനായിരിക്കും, അങ്ങനെ പലതും. വാദപ്രതിവാദങ്ങളുള്ള അലങ്കാരപ്പണിക്കാരെ വെറുതെ വിളിക്കുന്നു
ഒരു ഫംഗ്‌ഷൻ കോൾ പോലെ.

(വിത്ത്-ഡെക്കറേറ്റർ ഡെക്കറേറ്റർ-ഫൺ
(ചില പ്രവർത്തനങ്ങളെ നിർവചിക്കുക [] ...)

(with-decorator decorator1 decorator2 ...
(ചില പ്രവർത്തനങ്ങളെ നിർവചിക്കുക [] ...)

(വിത്ത്-ഡെക്കറേറ്റർ (ഡെക്കറേറ്റർ ആർഗ്) ..
(ചില പ്രവർത്തനങ്ങളെ നിർവചിക്കുക [] ...)

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, inc-decorator ഫംഗ്ഷൻ അലങ്കരിക്കാൻ ഉപയോഗിക്കുന്നു പുറമേ ഒരു കൂടെ
രണ്ട് പാരാമീറ്ററുകൾ എടുത്ത് അലങ്കരിച്ച ഫംഗ്‌ഷനെ മൂല്യങ്ങൾ ഉപയോഗിച്ച് വിളിക്കുന്ന ഫംഗ്‌ഷൻ
വർദ്ധിപ്പിച്ചത് 1. അലങ്കരിച്ചപ്പോൾ പുറമേ മൂല്യങ്ങൾ 1, 1 എന്നിവ ഉപയോഗിച്ച് വിളിക്കുന്നു, അവസാനം
ഫലം 4 ആയിരിക്കും (ക്സനുമ്ക്സ + ക്സനുമ്ക്സ + ക്സനുമ്ക്സ + ക്സനുമ്ക്സ).

=> (defn inc-decorator [func]
... (fn [മൂല്യം-1 മൂല്യം-2] (ഫൺ (+ മൂല്യം-1 1) (+ മൂല്യം-2 1)))
=> (defn inc2-decorator [func]
... (fn [മൂല്യം-1 മൂല്യം-2] (ഫൺ (+ മൂല്യം-1 2) (+ മൂല്യം-2 2)))

=> (with-decorator inc-decorator (defn added [ab] (+ ab)))
=> (കൂടാതെ 1 1)
4
=> (with-decorator inc2-decorator inc-decorator
... (defn കൂട്ടിച്ചേർക്കൽ [ab] (+ ab)))
=> (കൂടാതെ 1 1)
8

കൂടെ-ജെൻസിംസ്
0.9.12 പതിപ്പിൽ പുതിയത്.

കൂടെ-ജെൻസിം ഒരു കൂട്ടം സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു gensym ഒരു മാക്രോയിൽ ഉപയോഗിക്കുന്നതിന്. ഇനിപ്പറയുന്ന കോഡ്:

(ജെൻസിംസിനൊപ്പം [abc]
...)

ഇതിലേക്ക് വികസിക്കുന്നു:

(ആവട്ടെ [[a (gensym))
[ബി (ജെൻസിം)
[സി (ജെൻസിം)]]
...)

കാണുക കൂടാതെ:
ജെൻസിം ഉപയോഗിക്കുന്ന വിഭാഗം

വരുമാനം
വരുമാനം ഒന്നോ അതിലധികമോ മൂല്യങ്ങൾ നൽകുന്ന ഒരു ജനറേറ്റർ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. ജനറേറ്റർ
ഇത് ആവർത്തിക്കാവുന്നതാണ്, അതിനാൽ ലൂപ്പുകളിലും ലിസ്റ്റ് കോംപ്രിഹെൻഷനുകളിലും മറ്റ് സമാനതകളിലും ഉപയോഗിക്കാം
നിർമ്മിക്കുന്നു.

ഫങ്ഷൻ ക്രമരഹിത സംഖ്യകൾ അനന്തമായ ശ്രേണി സൃഷ്ടിക്കാൻ ജനറേറ്ററുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കുന്നു
അനന്തമായ മെമ്മറി ഉപഭോഗം ചെയ്യാതെ.

=> (defn ഗുണനം [അടിസ്ഥാന ഗുണകങ്ങൾ]
... ( [[(, അടിസ്ഥാന ഗുണകം) (സിപ്പ് ബേസ് കോഫിഫിഷ്യൻറുകൾ)]]
... (വിളവ് (* അടിസ്ഥാന ഗുണകം))))

=> (ഗുണിക്കുക (പരിധി 5) (പരിധി 5))


=> (ലിസ്റ്റ്-കോമ്പ് മൂല്യം [മൂല്യം (ഗുണിക്കുക (പരിധി 10) (പരിധി 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (റാൻഡം ഇറക്കുമതി ചെയ്യുക)
=> (റാൻഡം-നമ്പറുകൾ ഡിഫൻ ചെയ്യുക [കുറഞ്ഞ ഉയർന്നത്]
... (ശരിയായപ്പോൾ (വിളവ് (.റാൻഡം റാൻഡം ലോ ഹൈ))))
=> (list-comp x [x (15 എടുക്കുക (റാൻഡം-നമ്പറുകൾ 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

വിളവ്-നിന്ന്
0.9.13 പതിപ്പിൽ പുതിയത്.

പൈത്തൺ 3.3 ഒപ്പം UP മാത്രം!

വിളവ്-നിന്ന് ഒരു ഉപജനറേറ്ററിനെ വിളിക്കാൻ ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ കൊറൗട്ടിൻ വേണമെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്
ഫാൻസി പോലുള്ള എന്തെങ്കിലും ഉപയോഗിക്കുകയാണെങ്കിൽ അതിന്റെ പ്രക്രിയകൾ മറ്റൊരു കോറൂട്ടിനിലേക്ക് നിയോഗിക്കാൻ കഴിയും
അസിൻസിയോ.

Hy കോർ
കോർ പ്രവർത്തനങ്ങൾ
അവസാനം
ഉപയോഗം: (അവസാനം കോൾ)

അവസാനത്തെ ഇനം ഒഴികെ മറ്റെല്ലാവരുടേയും ഒരു ആവർത്തനം നൽകുന്നു കൂൾ.

=> (ലിസ്റ്റ് (ബട്ട്‌ലാസ്റ്റ് (പരിധി 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (ലിസ്റ്റ് (ബട്ട്‌ലാസ്റ്റ് [1]))
[]

=> (ലിസ്റ്റ് (ബട്ട്‌ലാസ്റ്റ് []))
[]

=> (ഇറർടൂളുകൾ ഇറക്കുമതി ചെയ്യുക)
=> (ലിസ്റ്റ് (5 എടുക്കുക (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

കോളോ?
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (coll? x)

റിട്ടേൺസ് ട്രൂ if x ആവർത്തിക്കാവുന്നതും ഒരു സ്ട്രിംഗല്ല.

=> (coll? [1 2 3 4])
ട്രൂ

=> (coll? {"a" 1 "b" 2})
ട്രൂ

=> (coll? "abc")
തെറ്റായ

കോണ്
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ദോഷങ്ങൾ a b)

കാറിനൊപ്പം ഒരു പുതിയ കോൺസ് സെൽ തിരികെ നൽകുന്നു a കൂടാതെ സി.ഡി.ആർ b.

=> (setv a (cons 'hd 'tl))

=> (= 'hd (കാർ a))
ട്രൂ

=> (= 'tl (cdr a))
ട്രൂ

ദോഷങ്ങൾ?
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ദോഷങ്ങൾ? foo)

എന്ന് പരിശോധിക്കുന്നു ഫൂ ഒരു കോൺസ് സെല്ലാണ്.

=> (setv a (cons 'hd 'tl))

=> (കോൺസ്? എ)
ട്രൂ

=> (കോൺസ്? ഇല്ല)
തെറ്റായ

=> (ദോഷങ്ങൾ? [1 2 3])
തെറ്റായ

ഡിസംബർ
ഉപയോഗം: (ഡിസം x)

ഒന്നിൽ കുറവ് നൽകുന്നു x. തുല്യമായ (- x 1). ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (ഡിസംബർ 3)
2

=> (ഡിസംബർ 0)
-1

=> (ഡിസംബർ 12.3)
11.3

ഡിസ്അസംബ്ലിംഗ്
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (വിഘടിപ്പിക്കുക വൃക്ഷം &ഓപ്ഷണൽ [കോഡെജൻ തെറ്റായ])

നൽകിയിരിക്കുന്ന Hy യ്‌ക്ക് പൈത്തൺ AST ഇടുക വൃക്ഷം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക്. എങ്കിൽ കോഡെജൻ is ട്രൂ, പ്രവർത്തനം
പകരം പൈത്തൺ കോഡ് പ്രിന്റ് ചെയ്യുന്നു.

=> (ഡിഅസംബ്ലിംഗ് '("ഹലോ വേൾഡ്!" അച്ചടിക്കുക))
മൊഡ്യൂൾ(
ശരീരം=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], keywords=[], starargs=ഒന്നുമില്ല, kwargs=ഒന്നുമില്ല))])

=> (വിഘടിപ്പിക്കുക '("ഹലോ വേൾഡ് അച്ചടിക്കുക!") true)
പ്രിന്റ് ('ഹലോ വേൾഡ്!')

ശൂന്യമോ?
ഉപയോഗം: (ശൂന്യം? കോൾ)

റിട്ടേൺസ് ട്രൂ if കൂൾ കാലിയാണ്. തുല്യമായ (= 0 (ലെൻ കോൾ)).

=> (ശൂന്യമാണോ? [])
ട്രൂ

=> (ശൂന്യമാണോ? "")
ട്രൂ

=> (ശൂന്യമാണോ? (, 1 2))
തെറ്റായ

ഓരോന്നോ?
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (എല്ലാവരും? മുൻ കോൾ)

റിട്ടേൺസ് ട്രൂ if (മുൻപ് x) ഓരോന്നിനും യുക്തിസഹമാണ് x in കൂൾ, അല്ലെങ്കിൽ തെറ്റായ. മടങ്ങുക ട്രൂ
if കൂൾ ശൂന്യമാണ്.

=> (ഓരോ? പോലും? [2 4 6])
ട്രൂ

=> (ഓരോ? പോലും? [1 3 5])
തെറ്റായ

=> (ഓരോ? പോലും? [2 4 5])
തെറ്റായ

=> (ഓരോ? പോലും? [])
ട്രൂ

ഫ്ലോട്ട്?
ഉപയോഗം: (ഫ്ലോട്ട്? x)

റിട്ടേൺസ് ട്രൂ if x ഒരു ഫ്ലോട്ട് ആണ്.

=> (ഫ്ലോട്ട്? 3.2)
ട്രൂ

=> (ഫ്ലോട്ട്? -2)
തെറ്റായ

പോലും?
ഉപയോഗം: (പോലും? x)

റിട്ടേൺസ് ട്രൂ if x സമമാണ്. ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (പോലും? 2)
ട്രൂ

=> (പോലും? 13)
തെറ്റായ

=> (പോലും? 0)
ട്രൂ

ഐഡന്റിറ്റി
ഉപയോഗം: (ഐഡന്റിറ്റി x)

ഫംഗ്‌ഷനിലേക്ക് നൽകിയ ആർഗ്യുമെന്റ് നൽകുന്നു.

=> (ഐഡന്റിറ്റി 4)
4

=> (ലിസ്റ്റ് (മാപ്പ് ഐഡന്റിറ്റി [1 2 3 4]))
[1 2 3 4]

Inc
ഉപയോഗം: (inc x)

ഒന്നിലധികം നൽകുന്നു x. തുല്യമായ (+ x 1). ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (inc 3)
4

=> (inc 0)
1

=> (inc 12.3)
13.3

ഉദാഹരണം?
ഉപയോഗം: (ഉദാഹരണം? ക്ലാസ് x)

റിട്ടേൺസ് ട്രൂ if x എന്നതിന്റെ ഒരു ഉദാഹരണമാണ് ക്ലാസ്.

=> (ഉദാഹരണം? ഫ്ലോട്ട് 1.0)
ട്രൂ

=> (ഉദാഹരണം? int 7)
ട്രൂ

=> (ഉദാഹരണം? str (str "foo"))
ട്രൂ

=> (defclass TestClass [object])
=> (setv inst (TestClass))
=> (ഉദാഹരണം? TestClass inst)
ട്രൂ

പൂർണ്ണസംഖ്യ?
ഉപയോഗം: (പൂർണ്ണസംഖ്യ? x)

റിട്ടേൺസ് ട്രൂ if x ഒരു പൂർണ്ണസംഖ്യയാണ്. പൈത്തൺ 2-ന്, ഇത് ഒന്നുകിൽ int or നീളമുള്ള. പൈത്തൺ 3-ന്,
ഇതാണ് int.

=> (പൂർണ്ണസംഖ്യ? 3)
ട്രൂ

=> (പൂർണ്ണസംഖ്യ? -2.4)
തെറ്റായ

ഇടവേള
0.10.1 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ഇന്റർലീവ് seq1 seq2 ...)

ഓരോ സീക്വൻസിലും ആദ്യ ഇനം, പിന്നെ രണ്ടാമത്തേത് മുതലായവ നൽകുന്നു.

=> (ലിസ്റ്റ് (ഇന്റർലീവ് (റേഞ്ച് 5) (പരിധി 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (ലിസ്റ്റ് (ഇന്റർലീവ് (പരിധി 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

ഇടപെടുക
0.10.1 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ഇടപെടുക ഇനം seq)

ഇനം കൊണ്ട് വേർതിരിക്കുന്ന ക്രമത്തിലെ മൂലകങ്ങളുടെ ഒരു ഐറ്റബിൾ നൽകുന്നു.

=> (ലിസ്‌റ്റ് ("!" "abcd" ഇന്റർപോസ് ചെയ്യുക))
['എ ബി സി ഡി']

=> (ലിസ്റ്റ് (ഇന്റർപോസ് -1 (റേഞ്ച് 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

ആവർത്തിക്കാനാകുമോ?
ഉപയോഗം: (ആവർത്തിക്കാവുന്നത്? x)

റിട്ടേൺസ് ട്രൂ if x ആവർത്തിക്കാവുന്നതാണ്. ആവർത്തിക്കാവുന്ന ഒബ്‌ജക്‌റ്റുകൾ എപ്പോൾ ഒരു പുതിയ ഇറ്ററേറ്റർ നൽകുന്നു (ഇറ്റർ x) is
വിളിച്ചു. കോൺട്രാസ്റ്റ് ആവർത്തനക്കാരൻ?.

=> ;; സ്ട്രിങ്ങുകൾക്കായി പ്രവർത്തിക്കുന്നു
=> (ആവർത്തിക്കാനാകുമോ? (str "abcde"))
ട്രൂ

=> ;; ലിസ്റ്റുകൾക്കായി പ്രവർത്തിക്കുന്നു
=> (ആവർത്തിക്കാനാകുമോ? [1 2 3 4 5])
ട്രൂ

=> ;; ട്യൂപ്പിൾസ് വേണ്ടി പ്രവർത്തിക്കുന്നു
=> (ആവർത്തിക്കാവുന്നത്? (, 1 2 3))
ട്രൂ

=> ;; ഡിക്ടുകൾക്കായി പ്രവർത്തിക്കുന്നു
=> (ആവർത്തിക്കാവുന്നതാണോ? {:a 1 :b 2 :c 3})
ട്രൂ

=> ;; ഇറ്ററേറ്ററുകൾ/ജനറേറ്ററുകൾക്കായി പ്രവർത്തിക്കുന്നു
=> (ആവർത്തിക്കാവുന്നതാണോ? (3 ആവർത്തിക്കുക))
ട്രൂ

ആവർത്തനക്കാരൻ?
ഉപയോഗം: (ഇറ്ററേറ്റർ? x)

റിട്ടേൺസ് ട്രൂ if x ഒരു ആവർത്തനമാണ്. ഇറ്ററേറ്ററുകൾ ഒരു വസ്തുവായി സ്വയം തിരികെ വരുന്ന വസ്തുക്കളാണ്
എപ്പോൾ ഇറ്ററേറ്റർ (ഇറ്റർ x) വിളിച്ചു. കോൺട്രാസ്റ്റ് ആവർത്തിക്കാനാകുമോ?.

=> ;; ഒരു ലിസ്റ്റിനായി പ്രവർത്തിക്കുന്നില്ല
=> (ഇറ്ററേറ്റർ? [1 2 3 4 5])
തെറ്റായ

=> ;; എന്നാൽ നമുക്ക് ലിസ്റ്റിൽ നിന്ന് ഒരു ഐറ്റർ ലഭിക്കും
=> (ഇറ്ററേറ്റർ? (ഇറ്റർ [1 2 3 4 5]))
ട്രൂ

=> ;; ആജ്ഞയ്ക്കായി പ്രവർത്തിക്കുന്നില്ല
=> (ഇറ്ററേറ്റർ? {:a 1 :b 2 :c 3})
തെറ്റായ

=> ;; ആജ്ഞയിൽ നിന്ന് ഒരു ആവർത്തനം സൃഷ്ടിക്കുക
=> (ഇറ്ററേറ്റർ? (ഇറ്റർ {:a 1 :b 2 :c 3}))
ട്രൂ

പട്ടിക*
ഉപയോഗം: (ലിസ്റ്റ്* തല &വിശ്രമിക്കുക വാൽ)

ആർഗ്യുമെന്റുകൾ അടങ്ങിയ നെസ്റ്റഡ് കോൺസ് സെല്ലുകളുടെ ഒരു ശൃംഖല (ഒരു ഡോട്ട് ഇട്ട ലിസ്റ്റ്) സൃഷ്ടിക്കുന്നു. എങ്കിൽ
ആർഗ്യുമെന്റ് ലിസ്റ്റിൽ ഒരു ഘടകം മാത്രമേയുള്ളൂ, അത് തിരികെ നൽകുക.

=> (ലിസ്റ്റ്* 1 2 3 4)
(1 2 3. 4)

=> (ലിസ്റ്റ്* 1 2 3 [4])
[1, 2, 3, 4]

=> (ലിസ്റ്റ്* 1)
1

=> (ദോഷങ്ങൾ? (ലിസ്റ്റ്* 1 2 3 4))
ട്രൂ

മാക്രോ വിപുലീകരിക്കുക
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (മാക്രോ വിപുലീകരിക്കുക ഫോം)

യുടെ പൂർണ്ണ മാക്രോ വികാസം നൽകുന്നു രൂപം.

=> (മാക്രോ എക്സ്പാൻഡ് '(-> (ab) (xy)))
(u'x' (u'a' u'b') u'y')

=> (macroexpand '(-> (ab) (-> (cd) (ef))))
(u'e' (u'c' (u'a' u'b') u'd') u'f')

മാക്രോ എക്സ്പാൻഡ്-1
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (മാക്രോ എക്സ്പാൻഡ്-1 ഫോം)

ന്റെ സിംഗിൾ സ്റ്റെപ്പ് മാക്രോ എക്സ്പാൻഷൻ നൽകുന്നു രൂപം.

=> (macroexpand-1 '(-> (ab) (-> (cd) (ef)))
(u'_>' (u'a' u'b') (u'c' u'd') (u'e' u'f'))

ലയിക്കുക-കൂടെ
0.10.1 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ലയിപ്പിക്കുക f &വിശ്രമിക്കുക മാപ്പുകൾ)

ആദ്യം ചേർത്ത മാപ്പുകളുടെ ബാക്കിയുള്ളവ അടങ്ങുന്ന ഒരു മാപ്പ് നൽകുന്നു. ഒരു കീ സംഭവിക്കുകയാണെങ്കിൽ
ഒന്നിലധികം മാപ്പ്, രണ്ടാമത്തേതിൽ നിന്നുള്ള (ഇടത്തുനിന്നും വലത്തോട്ടും) മാപ്പിംഗ്(കൾ) സംയോജിപ്പിക്കും
വിളിക്കുന്നതിലൂടെ ഫലത്തിൽ മാപ്പിംഗ് (f ഫലം-ഇൻ-ഫലം വാൽ-ഇൻ-ലാറ്റർ).

=> (ലയിപ്പിക്കുക (fn [xy] (+ xy)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a': 11L, u'c': 30L, u'b': 20L}

നെഗ്?
ഉപയോഗം: (നെഗ്? x)

റിട്ടേൺസ് ട്രൂ if x പൂജ്യത്തേക്കാൾ കുറവാണ്. ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (നല്ലത്? -2)
ട്രൂ

=> (നിരപേക്ഷ? 3)
തെറ്റായ

=> (നിരപേക്ഷ? 0)
തെറ്റായ

ഇല്ലേ?
ഉപയോഗം: (പൂജ്യം? x)

റിട്ടേൺസ് ട്രൂ if x is ഇല്ല / ഒന്നുമില്ല.

=> (പൂജ്യം? ഇല്ല)
ട്രൂ

=> (പൂജ്യം? ഒന്നുമില്ല)
ട്രൂ

=> (പൂജ്യം? 0)
തെറ്റായ

=> (setf x nil)
=> (പൂജ്യം? x)
ട്രൂ

=> ;; list.append എപ്പോഴും ഒന്നും നൽകുന്നില്ല
=> (പൂജ്യം? (. [1 2 3] 4 ചേർക്കുക))
ട്രൂ

ഒന്നുമില്ലേ?
ഉപയോഗം: (ഒന്നുമില്ല? x)

റിട്ടേൺസ് ട്രൂ if x is ഒന്നുമില്ല.

=> (ഒന്നുമില്ല? ഒന്നുമില്ല)
ട്രൂ

=> (ഒന്നുമില്ല? 0)
തെറ്റായ

=> (setf x ഒന്നുമില്ല)
=> (ഒന്നുമില്ല? x)
ട്രൂ

=> ;; list.append എപ്പോഴും ഒന്നും നൽകുന്നില്ല
=> (ഒന്നുമില്ല? (. [1 2 3] 4 കൂട്ടിച്ചേർക്കുക))
ട്രൂ

nth
ഉപയോഗം: (nth കൂൾ n &ഓപ്ഷണൽ [സ്ഥിരസ്ഥിതി ഇല്ല])

തിരികെ നൽകുന്നു nഒരു ശേഖരത്തിലെ -th ഇനം, 0 മുതൽ എണ്ണുന്നു. സ്ഥിര മൂല്യം തിരികെ നൽകുക, ഇല്ല, എങ്കിൽ
പരിധിക്ക് പുറത്ത് (മറ്റൊരു തരത്തിൽ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ). ഉയർത്തുന്നു മൂല്യ പിശക് if n നെഗറ്റീവ് ആണ്.

=> (nth [1 2 4 7] 1)
2

=> (nth [1 2 4 7] 3)
7

=> (പൂജ്യം? (nth [1 2 4 7] 5))
ട്രൂ

=> (nth [1 2 4 7] 5 "സ്ഥിരസ്ഥിതി")
'സ്ഥിരസ്ഥിതി'

=> (nth (3 എടുക്കുക (ഡ്രോപ്പ് 2 [1 2 3 4 5 6])) 2))
5

=> (nth [1 2 4 7] -1)
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
...
മൂല്യ പിശക്: islice() ന്റെ സൂചികകൾ ഒന്നുമല്ല അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യ ആയിരിക്കണം: 0 <= x <= sys.maxsize.

സംഖ്യാപരമായ?
ഉപയോഗം: (സംഖ്യ? x)

റിട്ടേൺസ് ട്രൂ if x പൈത്തണിൽ നിർവചിച്ചിരിക്കുന്നത് പോലെ ഒരു സംഖ്യയാണ് നമ്പറുകൾ.എണ്ണം ക്ലാസ്.

=> (സംഖ്യ? -2)
ട്രൂ

=> (സംഖ്യ? 3.2)
ട്രൂ

=> (സംഖ്യ? "foo")
തെറ്റായ

വിചിത്രമായത്?
ഉപയോഗം: (വിചിത്രമായത്? x)

റിട്ടേൺസ് ട്രൂ if x വിചിത്രമാണ്. ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (വിചിത്രം? 13)
ട്രൂ

=> (വിചിത്രം? 2)
തെറ്റായ

=> (വിചിത്രം? 0)
തെറ്റായ

പോസ്?
ഉപയോഗം: (പോസ്? x)

റിട്ടേൺസ് ട്രൂ if x പൂജ്യത്തേക്കാൾ വലുതാണ്. ഉയർത്തുന്നു ടൈപ്പ് പിശക് if (അല്ല (സംഖ്യ? x)).

=> (പോസ്? 3)
ട്രൂ

=> (പോസ്? -2)
തെറ്റായ

=> (പോസ്? 0)
തെറ്റായ

സെക്കന്റ്
ഉപയോഗം: (രണ്ടാം കോൾ)

ഇതിലെ രണ്ടാമത്തെ അംഗത്തെ തിരികെ നൽകുന്നു കൂൾ. തുല്യമായ (നേടുക കൂൾ 1).

=> (രണ്ടാം [0 1 2])
1

കുറെ
0.10.0 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (ചിലത് മുൻ കോൾ)

ന്റെ ആദ്യ ലോജിക്കലി-ട്രൂ മൂല്യം നൽകുന്നു (മുൻപ് x) വല്ലതും x in കൂൾ, അല്ലെങ്കിൽ ഇല്ല.
മടങ്ങുക ഇല്ല if കൂൾ ശൂന്യമാണ്.

=> (ചിലത് പോലും? [2 4 6])
ട്രൂ

=> (പൂജ്യം? (ചിലത് പോലും? [1 3 5]))
ട്രൂ

=> (പൂജ്യം? (ചില ഐഡന്റിറ്റി [0 "" []]))
ട്രൂ

=> (ചില ഐഡന്റിറ്റി [0 "ശൂന്യമല്ലാത്ത സ്ട്രിംഗ്" []])
'ശൂന്യമല്ലാത്ത സ്ട്രിംഗ്'

=> (പൂജ്യം? (ചിലത് പോലും? []))
ട്രൂ

സ്ട്രിംഗ്?
ഉപയോഗം: (സ്ട്രിംഗ്? x)

റിട്ടേൺസ് ട്രൂ if x ഒരു ചരടാണ്.

=> (സ്ട്രിംഗ്? "ഫൂ")
ട്രൂ

=> (സ്ട്രിംഗ്? -2)
തെറ്റായ

ചിഹ്നം?
ഉപയോഗം: (ചിഹ്നം? x)

റിട്ടേൺസ് ട്രൂ if x ഒരു പ്രതീകമാണ്.

=> (ചിഹ്നം? 'foo)
ട്രൂ

=> (ചിഹ്നം? '[abc])
തെറ്റായ

പൂജ്യം?
ഉപയോഗം: (പൂജ്യം? x)

റിട്ടേൺസ് ട്രൂ if x പൂജ്യമാണ്.

=> (പൂജ്യം? 3)
തെറ്റായ

=> (പൂജ്യം? -2)
തെറ്റായ

=> (പൂജ്യം? 0)
ട്രൂ

അനുക്രമം പ്രവർത്തനങ്ങൾ
സീക്വൻസ് ഫംഗ്‌ഷനുകൾക്ക് ഒന്നുകിൽ അനന്തമായ ഒരു ശ്രേണി സൃഷ്ടിക്കാനോ പ്രവർത്തിക്കാനോ കഴിയും
ഒരു ലിസ്റ്റിലോ സമാനമായ കണ്ടെയ്‌നറിലോ ക്രമം പൂർണ്ണമായി സാക്ഷാത്കരിക്കേണ്ടത് ആവശ്യമാണ്. അവർ ഇത് ചെയ്യുന്നു
ഒരു പൈത്തൺ ഇറ്ററേറ്റർ തിരികെ നൽകുന്നു.

എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ഉദാഹരണമായി നമുക്ക് കാനോനിക്കൽ ഇൻഫിനിറ്റ് ഫിബൊനാച്ചി നമ്പർ ജനറേറ്റർ ഉപയോഗിക്കാം
ഈ പ്രവർത്തനങ്ങളിൽ ചിലത്.

(defn fib []
(സെറ്റ് എ 0)
(setv b 1)
(സത്യമാണെങ്കിലും
(വിളവ് എ)
(setv (, ab) (, b (+ ab)))))

ശ്രദ്ധിക്കുക (അതേസമയം യഥാർഥ ...) ലൂപ്പ്. ഞങ്ങൾ ഇത് REPL-ൽ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ,

=> (fib)


ഫംഗ്‌ഷൻ വിളിക്കുന്നത് ഒരു ഇറ്ററേറ്റർ മാത്രമേ നൽകൂ, പക്ഷേ ഞങ്ങൾ അത് ഉപയോഗിക്കുന്നതുവരെ പ്രവർത്തിക്കില്ല.
അനന്തമായ ലൂപ്പ് അത് വരെ പ്രവർത്തിക്കുമെന്നതിനാൽ ഇതുപോലൊന്ന് പരീക്ഷിക്കുന്നത് ശുപാർശ ചെയ്യുന്നില്ല
ലഭ്യമായ എല്ലാ റാമും ഉപയോഗിക്കുന്നു, അല്ലെങ്കിൽ ഈ സാഹചര്യത്തിൽ ഞാൻ അത് കൊല്ലുന്നതുവരെ.

=> (ലിസ്റ്റ് (fib))
[1] 91474 പേർ കൊല്ലപ്പെട്ടു

ആദ്യത്തെ 10 ഫിബൊനാച്ചി നമ്പറുകൾ ലഭിക്കാൻ, ഉപയോഗിക്കുക എടുക്കുക. അതല്ല എടുക്കുക ഒരു ജനറേറ്ററും തിരികെ നൽകുന്നു,
അതിനാൽ ഞാൻ അതിൽ നിന്ന് ഒരു ലിസ്റ്റ് ഉണ്ടാക്കുന്നു.

=> (ലിസ്റ്റ് (10 (fib) എടുക്കുക))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

സൂചിക 9-ൽ ഫിബൊനാച്ചി നമ്പർ ലഭിക്കാൻ, (0 മുതൽ ആരംഭിക്കുന്നു):

=> (nth (fib) 9)
34

സൈക്കിൾ
ഉപയോഗം: (ചക്രം കോൾ)

കോളിലെ അംഗങ്ങളുടെ അനന്തമായ ആവർത്തനം നൽകുന്നു.

=> (ലിസ്റ്റ് (7 എടുക്കുക (സൈക്കിൾ [1 2 3])))
[1, 2, 3, 1, 2, 3, X]

=> (ലിസ്റ്റ് (2 എടുക്കുക (സൈക്കിൾ [1 2 3])))
[1, 2]

വ്യത്യസ്തരായ
ഉപയോഗം: (വ്യത്യസ്തരായ കോൾ)

അദ്വിതീയ അംഗങ്ങൾ മാത്രം അടങ്ങുന്ന ഒരു ഇറ്ററേറ്റർ നൽകുന്നു കൂൾ.

=> (ലിസ്റ്റ് (വ്യത്യസ്‌തമായ [1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (ലിസ്റ്റ് (വ്യത്യസ്ത []))
[]

=> (ലിസ്റ്റ് (വ്യത്യസ്‌തമായ (ഇറ്റർ [1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

ഡ്രോപ്പ്
ഉപയോഗം: (ഡ്രോപ്പ് n കോൾ)

ആദ്യത്തേത് ഒഴിവാക്കിക്കൊണ്ട് ഒരു ഇറ്ററേറ്റർ നൽകുന്നു n അംഗങ്ങൾ കൂൾ. ഉയർത്തുന്നു മൂല്യ പിശക് if n is
നെഗറ്റീവ്.

=> (ലിസ്റ്റ് (ഡ്രോപ്പ് 2 [1 2 3 4 5]))
[XXX, 3, 4]

=> (ലിസ്റ്റ് (ഡ്രോപ്പ് 4 [1 2 3 4 5]))
[5]

=> (ലിസ്റ്റ് (ഡ്രോപ്പ് 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (ലിസ്റ്റ് (ഡ്രോപ്പ് 6 [1 2 3 4 5]))
[]

ഡ്രോപ്പ്-അവസാനം
ഉപയോഗം: (ഡ്രോപ്പ്-അവസാനം n കോൾ)

അവസാനത്തേത് ഒഴികെയുള്ളവയുടെ ഒരു ആവർത്തനം നൽകുന്നു n ഇനങ്ങൾ കൂൾ. ഉയർത്തുന്നു മൂല്യ പിശക് if n is
നെഗറ്റീവ്.

=> (ലിസ്റ്റ് (ഡ്രോപ്പ്-ലാസ്റ്റ് 5 (പരിധി 10 20)))
[10, 11, 12, 13, 14]

=> (ലിസ്റ്റ് (ഡ്രോപ്പ്-ലാസ്റ്റ് 0 (റേഞ്ച് 5)))
[0, 1, 2, 3, 4]

=> (ലിസ്റ്റ് (ഡ്രോപ്പ്-ലാസ്റ്റ് 100 (റേഞ്ച് 100)))
[]

=> (ഇറർടൂളുകൾ ഇറക്കുമതി ചെയ്യുക)
=> (ലിസ്റ്റ് (5 എടുക്കുക (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

വീഴുമ്പോൾ
ഉപയോഗം: (ഡ്രോപ്പ്-അതേസമയം മുൻ കോൾ)

അംഗങ്ങളെ ഒഴിവാക്കി ഒരു ഇറ്ററേറ്റർ നൽകുന്നു കൂൾ വരുവോളം മുൻ is തെറ്റായ.

=> (ലിസ്‌റ്റ് (ഡ്രോപ്പ്-അതേസമയം? [2 4 7 8 9]))
[XXX, 7, 8]

=> (ലിസ്‌റ്റ് (ഡ്രോപ്പ്-വെയിൽ ന്യൂമെറിക്? [1 2 3 ഒന്നുമില്ല "എ"])))
[ഒന്നുമില്ല, u'a']

=> (ലിസ്റ്റ് (ഡ്രോപ്പ്-വെയിൽ പോസ്? [2 4 7 8 9]))
[]

ഫിൽറ്റർ ചെയ്യുക
ഉപയോഗം: (ഫിൽട്ടർ മുൻ കോൾ)

എല്ലാ ഇനങ്ങൾക്കും ഒരു ഇറ്ററേറ്റർ നൽകുന്നു കൂൾ പ്രവചനം കടന്നുപോകുക മുൻ.

ഇതും കാണുക നീക്കം.

=> (ലിസ്റ്റ് (ഫിൽട്ടർ പോസ്? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (ലിസ്‌റ്റ് (ഫിൽട്ടർ പോലും? [1 2 3 -4 5 -7]))
[2, -4]

പരത്തുക
0.9.12 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (പരന്നതാക്കുക കോൾ)

എല്ലാ ഇനങ്ങളുടെയും ഒരൊറ്റ ലിസ്റ്റ് നൽകുന്നു കൂൾ, അടങ്ങിയിരിക്കുന്ന എല്ലാ ലിസ്റ്റുകളും കൂടാതെ/അല്ലെങ്കിൽ പരന്നതിലൂടെ
ട്യൂപ്പിൾസ്.

=> (പരന്നതാക്കുക [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (പരന്ന ["foo" (, 1 2) [1 [2 3] 4] "ബാർ"])
['foo', 1, 2, 1, 2, 3, 4, 'bar']

ആവർത്തിക്കുക
ഉപയോഗം: (ആവർത്തിക്കുക fn x)

ഒരു ഇറ്ററേറ്റർ നൽകുന്നു x, fn(x), fn(fn(x)), തുടങ്ങിയവ.

=> (ലിസ്റ്റ് (5 എടുക്കുക (ഇന്റേറ്റ് ഇൻക് 5)))
[5, 6, 7, 8, 9]

=> (ലിസ്റ്റ് (5 എടുക്കുക (ആവർത്തിക്കുക (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

വായിക്കുക
ഉപയോഗം: (വായിക്കുക &ഓപ്ഷണൽ [ഫയലിൽ നിന്ന് eof])

എന്നതിൽ നിന്നുള്ള അടുത്ത Hy എക്സ്പ്രഷൻ വായിക്കുന്നു ഫയലിൽ നിന്ന് (സ്ഥിരമായി sys.stdin), കൂടാതെ a എടുക്കാം
EOF ആയി സിംഗിൾ ബൈറ്റ് (ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് സ്ഥിരസ്ഥിതി). ഉയർത്തുന്നു EOFError if ഫയലിൽ നിന്ന് മുമ്പ് അവസാനിക്കുന്നു
ഒരു പൂർണ്ണമായ പദപ്രയോഗം പാഴ്‌സ് ചെയ്യാൻ കഴിയും.

=> (വായിക്കുക)
(+ 2 2)
('+' 2 2)
=> (ഇവൽ (വായിക്കുക))
(+ 2 2)
4

=> (ഇറക്കുമതി ഐഒ)
=> (ഡെഫ് ബഫർ (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (വായിക്കുക [] {"from_file" ബഫർ}))
4
=> (eval (വായിക്കുക [] {"from_file" ബഫർ}))
1

=> ; "example.hy" എന്നതിൽ അടങ്ങിയിരിക്കുന്നു:
=> ; ("ഹലോ" എന്ന് അച്ചടിക്കുക)
=> ; ("ഹൈഫ്രണ്ട്സ്!" എന്ന് അച്ചടിക്കുക)
=> (കൂടെ [[f ("example.hy" തുറക്കുക)]]
... (ശ്രമിക്കുക
... (സത്യമാണെങ്കിലും
... (അനുവദിക്കട്ടെ [[exp (read f)]]
... (ചെയ്യുക
... ("OHY" എക്‌സ്‌പ്രിന്റ് പ്രിന്റ് ചെയ്യുക)
... (eval exp))))
... (പിടിക്കുക [e EOFError]
... ("EOF!"))))
ഓഹ് ('പ്രിന്റ്' 'ഹലോ')
ഹലോ
ഓഹ് ('പ്രിന്റ്' 'ഹൈഫ്രണ്ട്സ്!')
കൂട്ടുകാർ!
EOF!

നീക്കം
ഉപയോഗം: (നീക്കം ചെയ്യുക മുൻ കോൾ)

എന്നതിൽ നിന്ന് ഒരു ഇറ്ററേറ്റർ നൽകുന്നു കൂൾ പ്രവചനം കടന്നുപോകുന്ന ഘടകങ്ങൾ ഉപയോഗിച്ച് മുൻ, നീക്കം ചെയ്തു.

ഇതും കാണുക ഫിൽറ്റർ ചെയ്യുക.

=> (വിചിത്രമായത് നീക്കം ചെയ്യണോ? [1 2 3 4 5 6 7]))
[XXX, 2, 4]

=> (ലിസ്റ്റ് (പോസ് നീക്കം ചെയ്യണോ? [1 2 3 4 5 6 7]))
[]

=> (ലിസ്റ്റ് (നെഗ് നീക്കം ചെയ്യണോ? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, X]

ആവർത്തിച്ച്
ഉപയോഗം: (ആവർത്തിച്ച് x)

ഒരു ഇറ്ററേറ്റർ (അനന്തം) നൽകുന്നു x.

=> (ലിസ്റ്റ് (6 എടുക്കുക ("s" ആവർത്തിക്കുക)))
[u's', u's', u's', u's', u's', u's']

ആവർത്തിച്ച്
ഉപയോഗം: (ആവർത്തിച്ച് fn)

വിളിക്കുന്നതിലൂടെ ഒരു ഇറ്ററേറ്റർ നൽകുന്നു fn ആവർത്തിച്ച്.

=> (ഇറക്കുമതി [റാൻഡം [റാൻഡിൻ]])

=> (ലിസ്റ്റ് (ആവർത്തിച്ച് 5 എടുക്കുക (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

എടുക്കുക
ഉപയോഗം: (എടുക്കുക n കോൾ)

ആദ്യത്തേത് അടങ്ങുന്ന ഒരു ഇറ്ററേറ്റർ നൽകുന്നു n അംഗങ്ങൾ കൂൾ. ഉയർത്തുന്നു മൂല്യ പിശക് if n is
നെഗറ്റീവ്.

=> (ലിസ്റ്റ് (3 [1 2 3 4 5] എടുക്കുക))
[XXX, 1, 2]

=> (ലിസ്റ്റ് (4 എടുക്കുക ("s" ആവർത്തിക്കുക)))
[u's', u's', u's', u's']

=> (ലിസ്റ്റ് (0 എടുക്കുക ("s" ആവർത്തിക്കുക)))
[]

എടുക്കുക-nth
ഉപയോഗം: (എടുക്കുക n കോൾ)

എല്ലാം അടങ്ങുന്ന ഒരു ഇറ്ററേറ്റർ നൽകുന്നു n-ലെ അംഗം കൂൾ.

=> (പട്ടിക (എടുക്കുക-nth 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (പട്ടിക (എടുക്കുക-nth 3 [1 2 3 4 5 6 7]))
[XXX, 1, 4]

=> (പട്ടിക (എടുക്കുക-nth 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (പട്ടിക (എടുക്കുക-nth 10 [1 2 3 4 5 6 7]))
[1]

എടുക്കുക-സമയം
ഉപയോഗം: (എടുക്കുക-സമയം മുൻ കോൾ)

എന്നതിൽ നിന്ന് ഒരു ഇറ്ററേറ്റർ നൽകുന്നു കൂൾ എത്ര കാലത്തോളം മുൻ വരുമാനം ട്രൂ.

=> (ലിസ്റ്റ് (എടുക്കുമ്പോൾ പോസ്? [1 2 3 -4 5]))
[XXX, 1, 2]

=> (ലിസ്‌റ്റ് (എടുക്കുമ്പോൾ വേണ്ടേ? [ -4 -3 1 2 5]))
[-4, -3]

=> (ലിസ്‌റ്റ് (എടുക്കുമ്പോൾ വേണ്ടേ? [1 2 3 -4 5]))
[]

zip ഉപയോഗിച്ച്
0.9.13 പതിപ്പിൽ പുതിയത്.

ഉപയോഗം: (സിപ്പ് ഉപയോഗിച്ച് fn കൂൾ ...)

തുല്യമായ സിപ്പ്, എന്നാൽ ഒരു ട്യൂപ്പിൾ സൃഷ്ടിക്കുന്നതിനുപകരം ഒരു മൾട്ടി-ആർഗ്യുമെന്റ് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. എങ്കിൽ
zip ഉപയോഗിച്ച് N ശേഖരങ്ങൾ ഉപയോഗിച്ച് വിളിക്കുന്നു, അപ്പോൾ fn N വാദങ്ങൾ അംഗീകരിക്കണം.

=> (ഇറക്കുമതി ഓപ്പറേറ്റർ)
=> (ലിസ്റ്റ് (zipwith operator.add [1 2 3] [4 5 6]))
[XXX, 5, 7]

വായനക്കാരൻ മാക്രോകൾ
റീഡർ മാക്രോകൾ ലിസ്‌പിന് ഈച്ചയിൽ വാക്യഘടന പരിഷ്‌ക്കരിക്കുന്നതിനും മാറ്റുന്നതിനുമുള്ള ശക്തി നൽകുന്നു. നിനക്ക് വേണ്ട
പോളിഷ് നൊട്ടേഷൻ? ഒരു റീഡർ മാക്രോയ്ക്ക് അത് എളുപ്പത്തിൽ ചെയ്യാൻ കഴിയും. ക്ലോജൂറിന്റെ വഴി വേണോ
regex? റീഡർ മാക്രോകൾക്കും ഇത് എളുപ്പത്തിൽ ചെയ്യാൻ കഴിയും.

പദവിന്യാസം
=> (defreader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1)
=> #^"ഹലോ"
"ഹലോ"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

ഹൈയ്‌ക്ക് ട്യൂപ്പിൾസിന് അക്ഷരാർത്ഥമില്ല. നിങ്ങൾക്ക് ഇഷ്ടമല്ലെന്ന് പറയാം (, ...) വേറെ എന്തെങ്കിലും വേണം. ഈ
റീഡർ മാക്രോകൾക്ക് വൃത്തിയായി പരിഹരിക്കാൻ കഴിയുന്ന ഒരു പ്രശ്നമാണ്.

=> (defreader t [expr] `(, ~@expr))
=> #t(1 2 3)
(1, 2, 3)

നിങ്ങൾക്ക് ഇത് ക്ലോജൂരെ പോലെ ചെയ്യാനും പതിവ് പദപ്രയോഗങ്ങൾക്ക് അക്ഷരാർത്ഥത്തിൽ നൽകാനും കഴിയും!

=> (വീണ്ടും ഇറക്കുമതി ചെയ്യുക)
=> (defreader r [expr] `(re.compile ~expr))
=> #r".*"
<_sre.SRE_Pattern object at 0xcv7713ph15#>

നടപ്പിലാക്കൽ
defreader റീഡർ മാക്രോയുടെ ചിഹ്ന നാമമായി ഒരൊറ്റ പ്രതീകം എടുക്കുന്നു; ഇനി എന്തും
ഒരു പിശക് തിരികെ നൽകും. നടപ്പാക്കൽ അടിസ്ഥാനത്തിൽ, defreader a കൊണ്ട് പൊതിഞ്ഞ ഒരു ലാംഡയായി വികസിക്കുന്നു
അലങ്കാരപ്പണിക്കാരൻ. ഈ ഡെക്കറേറ്റർ ലാംഡയെ അതിന്റെ മൊഡ്യൂൾ നാമം ഉപയോഗിച്ച് ഒരു നിഘണ്ടുവിൽ സംരക്ഷിക്കുന്നു
ചിഹ്നം.

=> (defreader ^ [expr] (print expr))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (print expr)))

# ആയി വികസിക്കുന്നു (dispatch_reader_macro ...) ചിഹ്നവും പദപ്രയോഗവും എവിടെയാണ് കൈമാറുന്നത്
ശരിയായ പ്രവർത്തനം.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"ഹലോ"
"ഹലോ"

മുന്നറിയിപ്പ്:
ഹൈയുടെ ലെക്സറിലും പാർസറിലുമുള്ള പരിമിതി കാരണം, റീഡർ മാക്രോകൾക്ക് നിർവചിക്കപ്പെട്ടത് പുനർനിർവചിക്കാൻ കഴിയില്ല
പോലുള്ള വാക്യഘടന ()[]{}. ഇത് മിക്കവാറും ഭാവിയിൽ പരിഹരിക്കപ്പെടും.

ആന്തരിക Hy വിവരണക്കുറിപ്പു്
ശ്രദ്ധിക്കുക:
ഹൈ-യിൽ തന്നെ ഹാക്ക് ചെയ്യുന്ന ആളുകൾക്ക് ഈ ബിറ്റുകൾ കൂടുതലും ഉപയോഗപ്രദമാണ്, പക്ഷേ അവയ്ക്കും ഉപയോഗിക്കാവുന്നതാണ്
മാക്രോ പ്രോഗ്രാമിംഗിൽ ആഴത്തിൽ ആഴ്ന്നിറങ്ങുന്നവർ.

Hy മോഡലുകൾ
അവതാരിക ലേക്ക് Hy മോഡലുകൾ
ഹൈ മോഡലുകൾ സാധാരണ പൈത്തൺ ഒബ്‌ജക്റ്റുകളുടെ മുകളിലുള്ള വളരെ നേർത്ത പാളിയാണ്, ഇത് ഹൈ ഉറവിടത്തെ പ്രതിനിധീകരിക്കുന്നു
ഡാറ്റയായി കോഡ്. മോഡലുകൾ ഉറവിട സ്ഥാന വിവരങ്ങളും ഒരുപിടി രീതികളും മാത്രമേ ചേർക്കൂ
ഹൈ സോഴ്‌സ് കോഡിന്റെ ക്ലീൻ മാനിപ്പുലേഷനെ പിന്തുണയ്ക്കുക, ഉദാഹരണത്തിന് മാക്രോകളിൽ. അത് നേടിയെടുക്കാൻ
ലക്ഷ്യം, ഹൈ മോഡലുകൾ അടിസ്ഥാന പൈത്തൺ ക്ലാസിന്റെ മിക്സിനുകളാണ് ഹൈഒബ്ജക്റ്റ്.

ഹൈഒബ്ജക്റ്റ്
hy.models.HyObject ഹൈ മോഡലുകളുടെ അടിസ്ഥാന ക്ലാസ് ആണ്. ഇത് ഒരു രീതി മാത്രം നടപ്പിലാക്കുന്നു, മാറ്റിസ്ഥാപിക്കാൻ,
നിലവിലെ ഒബ്‌ജക്‌റ്റിന്റെ ഉറവിട സ്ഥാനത്തെ ആർഗ്യുമെന്റായി പാസ്സാക്കിയ ഒന്ന് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.
മാറ്റം വരുത്തുന്ന എക്സ്പ്രഷനുകളുടെ യഥാർത്ഥ സ്ഥാനം ട്രാക്ക് ചെയ്യാൻ ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു
മാക്രോകൾ, അത് കംപൈലറിലോ ശുദ്ധമായ ഹൈ മാക്രോയിലോ ആകട്ടെ.

ഹൈഒബ്ജക്റ്റ് ഹൈ മോഡലുകൾ തൽക്ഷണം ചെയ്യാൻ നേരിട്ട് ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല, മറിച്ച് ഒരു മിക്‌സിനായി മാത്രം
മറ്റ് ക്ലാസുകൾക്ക്.

കോമ്പൗണ്ട് മോഡലുകൾ
പരാൻതീസൈസ് ചെയ്തതും ബ്രാക്കറ്റുള്ളതുമായ ലിസ്റ്റുകൾ ഹൈ പാഴ്‌സർ സംയുക്ത മോഡലുകളായി പാഴ്‌സ് ചെയ്യുന്നു.

ഹൈലിസ്റ്റ്
hy.models.list.HyList "ഇറ്റബിൾ" ഹൈ മോഡലുകളുടെ അടിസ്ഥാന ക്ലാസ് ആണ്. എന്നതാണ് അതിന്റെ അടിസ്ഥാന ഉപയോഗം
ബ്രാക്കറ്റഡ് പ്രതിനിധീകരിക്കുന്നു [] ലിസ്‌റ്റുകൾ, ഒരു ടോപ്പ് ലെവൽ എക്‌സ്‌പ്രഷൻ ആയി ഉപയോഗിക്കുമ്പോൾ വിവർത്തനം ചെയ്യുന്നു
പൈത്തൺ ലിസ്റ്റ് ലിറ്ററലുകൾ സമാഹരിക്കുന്ന ഘട്ടത്തിലാണ്.

മറ്റൊരു ഐറ്റബിൾ ഒബ്‌ജക്‌റ്റിലേക്ക് ഒരു ഹൈലിസ്‌റ്റ് ചേർക്കുന്നത് ഇടതുവശത്തുള്ള ഒബ്‌ജക്‌റ്റിന്റെ ക്ലാസ് വീണ്ടും ഉപയോഗിക്കുന്നു,
ഒരു മാക്രോയിൽ Hy ഒബ്‌ജക്‌റ്റുകൾ സംയോജിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഉപയോഗപ്രദമായ ഒരു പെരുമാറ്റം, ഉദാഹരണത്തിന്.

ഹൈഎക്സ്പ്രഷൻ
hy.models.expression.HyExpression അവകാശമാക്കുന്നു ഹൈലിസ്റ്റ് പരാൻതീസൈസ് ചെയ്തതിന് () ഭാവങ്ങൾ. ദി
ആ പദപ്രയോഗങ്ങളുടെ സമാഹാര ഫലം പട്ടികയിലെ ആദ്യ ഘടകത്തെ ആശ്രയിച്ചിരിക്കുന്നു:
കമ്പൈലർ സ്പെഷ്യൽ ഫോമുകൾ, ഉപയോക്തൃ നിർവചിച്ച മാക്രോകൾ എന്നിവയ്ക്കിടയിൽ എക്സ്പ്രഷനുകൾ അയയ്ക്കുന്നു.
സാധാരണ പൈത്തൺ ഫംഗ്‌ഷൻ കോളുകൾ.

ഹൈഡിക്റ്റ്
hy.models.dict.HyDict അവകാശമാക്കുന്നു ഹൈലിസ്റ്റ് ചുരുണ്ട ബ്രാക്കറ്റിന് {} കംപൈൽ ചെയ്യുന്ന എക്സ്പ്രഷനുകൾ
അക്ഷരാർത്ഥത്തിൽ പൈത്തൺ നിഘണ്ടുവിലേക്ക്.

അടിസ്ഥാന ക്ലാസായി ഒരു ഡിക്‌റ്റിന് പകരം ഒരു ലിസ്റ്റ് ഉപയോഗിക്കാനുള്ള തീരുമാനം ഹൈഡിക്റ്റ് എളുപ്പം അനുവദിക്കുന്നു
കോമ്പൗണ്ട് എക്‌സ്‌പ്രഷനുകൾ അനുവദിക്കുന്നതിന്റെ അധിക നേട്ടത്തോടൊപ്പം മാക്രോകളിലെ ഡിക്‌റ്റുകളുടെ കൃത്രിമത്വം
ഡിക്റ്റ് കീകളായി (ഉദാഹരണത്തിന്, the ഹൈഎക്സ്പ്രഷൻ പൈത്തൺ ക്ലാസ് ഹാഷബിൾ അല്ല).

ആറ്റോമിക് മോഡലുകൾ
ഇൻപുട്ട് സ്ട്രീമിൽ, സ്ട്രിംഗുകൾക്കുള്ള പൈത്തൺ നൊട്ടേഷനെ മാനിച്ചുകൊണ്ട്, ഇരട്ട-ഉദ്ധരിച്ച സ്ട്രിംഗുകൾ,
ഒരൊറ്റ ടോക്കണായി പാഴ്‌സ് ചെയ്യുന്നു, അത് നേരിട്ട് a ആയി പാഴ്‌സ് ചെയ്യുന്നു ഹൈസ്ട്രിംഗ്.

സ്‌പെയ്‌സുകൾ, ബ്രാക്കറ്റുകൾ, ഉദ്ധരണികൾ, ഇരട്ട ഉദ്ധരണികൾ എന്നിവ ഒഴികെയുള്ള പ്രതീകങ്ങളുടെ തടസ്സമില്ലാത്ത സ്ട്രിംഗ്
അഭിപ്രായങ്ങളും, ഒരു ഐഡന്റിഫയറായി പാഴ്‌സ് ചെയ്‌തിരിക്കുന്നു.

ഇനിപ്പറയുന്ന ക്രമത്തിൽ പാഴ്സിംഗ് ഘട്ടത്തിൽ ഐഡന്റിഫയറുകൾ ആറ്റോമിക് മോഡലുകളിലേക്ക് പരിഹരിച്ചിരിക്കുന്നു:

· ഹൈഇന്റേജർ

· ഹൈഫ്ലോട്ട്

· ഹൈകോംപ്ലക്സ് (ആറ്റം നഗ്നമല്ലെങ്കിൽ j)

· ഹൈകീവേഡ് (ആറ്റം ആരംഭിക്കുകയാണെങ്കിൽ :)

· ഹൈസിംബൽ

ഹൈസ്ട്രിംഗ്
hy.models.string.HyString സ്ട്രിംഗ് തുല്യമായ ഹൈ മോഡലുകളുടെ അടിസ്ഥാന ക്ലാസ് ആണ്. അതും
ഇരട്ട-ഉദ്ധരിച്ച സ്ട്രിംഗ് അക്ഷരങ്ങളെ പ്രതിനിധീകരിക്കുന്നു, "", ഇത് യൂണികോഡ് സ്ട്രിംഗിലേക്ക് കംപൈൽ ചെയ്യുന്നു
പൈത്തണിലെ അക്ഷരങ്ങൾ. ഹൈസ്ട്രിംഗ്സ് പൈത്തൺ 2-ലും സ്ട്രിംഗ് ഒബ്‌ജക്‌റ്റുകളും ഇൻഹെറിറ്റ് ചെയ്യുക
പൈത്തൺ 3 (അതിനാൽ എൻകോഡിംഗിനെ ആശ്രയിക്കുന്നില്ല).

ഹൈസ്ട്രിംഗ് അടിസ്ഥാന മോഡലുകൾ മാറ്റമില്ലാത്തവയാണ്.

ഹൈ ലിറ്ററൽ സ്‌ട്രിംഗുകൾക്ക് ഒന്നിലധികം വരികൾ പരത്താൻ കഴിയും, അവ ഒറ്റയടിയായി പാഴ്‌സർ കണക്കാക്കുന്നു
യൂണിറ്റ്, യൂണികോഡ് സ്ട്രിംഗുകൾക്കായി പൈത്തൺ എസ്കേപ്പുകളെ ബഹുമാനിക്കുന്നു.

സംഖ്യാ മോഡലുകൾ
hy.models.integer.HyInteger പൂർണ്ണസംഖ്യ ലിറ്ററലുകളെ പ്രതിനിധീകരിക്കുന്നു (ഉപയോഗിക്കുന്നത് നീളമുള്ള പൈത്തൺ 2-ൽ ടൈപ്പ് ചെയ്യുക,
ഒപ്പം int പൈത്തണിൽ 3).

hy.models.float.HyFloat ഫ്ലോട്ടിംഗ് പോയിന്റ് ലിറ്ററലുകളെ പ്രതിനിധീകരിക്കുന്നു.

hy.models.complex.HyComplex സങ്കീർണ്ണമായ അക്ഷരങ്ങളെ പ്രതിനിധീകരിക്കുന്നു.

അനുബന്ധ പൈത്തൺ ദിനചര്യയും സാധുവായ സംഖ്യാ പൈത്തണും ഉപയോഗിച്ച് സംഖ്യാ മോഡലുകൾ പാഴ്‌സ് ചെയ്യുന്നു
അക്ഷരങ്ങൾ അവയുടെ ഹൈ പ്രതിരൂപമായി മാറും.

ഹൈസിംബൽ
hy.models.symbol.HySymbol ഹൈ ഭാഷയിലെ ചിഹ്നങ്ങളെ പ്രതിനിധീകരിക്കാൻ ഉപയോഗിക്കുന്ന മാതൃകയാണ്. അത്
അവകാശമാക്കുന്നു ഹൈസ്ട്രിംഗ്.

ഹൈസിംബൽ പൈത്തൺ ഇന്ററോപ്പറബിളിറ്റിയെ സഹായിക്കുന്നതിന് പാഴ്‌സിംഗ് ഘട്ടത്തിൽ ഒബ്‌ജക്റ്റുകൾ മംഗൾ ചെയ്യപ്പെടുന്നു:

· നക്ഷത്രചിഹ്നങ്ങളാൽ ചുറ്റപ്പെട്ട ചിഹ്നങ്ങൾ (*) വലിയക്ഷരമാക്കി മാറ്റുന്നു;

· ഡാഷുകൾ (-) അടിവരകളാക്കി മാറ്റുന്നു (_);

· ഒരു പിന്നിലുള്ള ചോദ്യചിഹ്നം (?) ഒരു മുൻനിരയായി മാറി ആണ്_.

മുന്നറിയിപ്പ്: പാഴ്‌സിംഗ് ഘട്ടത്തിൽ മാംഗ്ലിംഗ് നടക്കുന്നതിനാൽ, ഇത് സാധ്യമാണ്
ഹൈ സോഴ്‌സ് കോഡ് ഉപയോഗിച്ച് സൃഷ്‌ടിക്കാൻ കഴിയാത്ത ഹൈസിംബലുകൾ പ്രോഗ്രമാറ്റിക്കായി സൃഷ്‌ടിക്കുക. അത്തരം എ
"ഇൻറേൺഡ്" ചിഹ്നങ്ങൾ സൃഷ്ടിക്കാൻ ജെൻസിം മെക്കാനിസം ഉപയോഗിക്കുന്നു.

ഹൈകീവേഡ്
hy.models.keyword.HyKeyword ഹൈയിലെ കീവേഡുകളെ പ്രതിനിധീകരിക്കുന്നു. എന്ന് തുടങ്ങുന്ന ചിഹ്നങ്ങളാണ് കീവേഡുകൾ
a :. ക്ലാസ് പാരമ്പര്യമായി ലഭിക്കുന്നു ഹൈസ്ട്രിംഗ്.

വേർതിരിച്ചറിയാൻ ഹൈകീവേഡുകൾ നിന്ന് ഹൈസിംബലുകൾ, (അനിയന്ത്രിതമായ) സാധ്യതയില്ലാതെ
ക്ലാഷുകൾ, സ്വകാര്യ ഉപയോഗ യൂണികോഡ് പ്രതീകം "\uFDD0" ലിറ്ററൽ എന്ന കീവേഡിന് മുൻകൈയെടുത്തു
സംഭരണത്തിന് മുമ്പ്.

ബാക്ക്ട്രെയിസ്കൊണ്ടു് കളങ്ങൾ
hy.models.cons.HyCons പൈത്തൺ-സൗഹൃദത്തിന്റെ പ്രതിനിധാനമാണ് കോണ് കളങ്ങൾ. ദോഷ കോശങ്ങളാണ്
സ്കീം അല്ലെങ്കിൽ കോമൺ പോലുള്ള "സാധാരണ" LISP വേരിയന്റുകളുടെ സവിശേഷതകൾ അനുകരിക്കാൻ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
ലിസ്പ്.

ഒരു കോൺസ് സെൽ എന്നത് 2 ഇനങ്ങളുള്ള ഒരു വസ്തുവാണ്, അതിൽ a അടങ്ങിയിരിക്കുന്നു കാര് (തല) കൂടാതെ എ സിഡിആർ (വാൽ). ചില ലിസ്പിൽ
വകഭേദങ്ങളിൽ, കോൺസ് സെൽ അടിസ്ഥാന നിർമ്മാണ ബ്ലോക്കാണ്, എസ്-എക്‌സ്‌പ്രഷനുകളാണ് യഥാർത്ഥത്തിൽ
കോൺസ് സെല്ലുകളുടെ ലിങ്ക്ഡ് ലിസ്റ്റുകളായി പ്രതിനിധീകരിക്കുന്നു. സാധാരണ പോലെ ഹൈയിൽ ഇതല്ല സ്ഥിതി
a-യിൽ പൊതിഞ്ഞ പൈത്തൺ ലിസ്റ്റുകൾ ഉപയോഗിച്ചാണ് പദപ്രയോഗങ്ങൾ നിർമ്മിച്ചിരിക്കുന്നത് ഹൈഎക്സ്പ്രഷൻ. എന്നിരുന്നാലും, ആ ഹൈക്കോൺസ്
"സാധാരണ" Lisp വേരിയന്റുകളുടെ സ്വഭാവം ഇങ്ങനെ അനുകരിക്കുന്നു:

· (ദോഷങ്ങൾ എന്തെങ്കിലും ഇല്ല) is (ഹൈഎക്സ്പ്രഷൻ [എന്തെങ്കിലും])

· (ദോഷങ്ങൾ എന്തെങ്കിലും ചില പട്ടിക) is ((തരം ചില പട്ടിക) (+ [എന്തെങ്കിലും] ചില-ലിസ്റ്റ്)) (അങ്ങനെയെങ്കിൽ
ചില-ലിസ്റ്റ് നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു പട്ടിക).

· (നേടുക (ദോഷങ്ങൾ a b) 0) is a

· (കഷണം (ദോഷങ്ങൾ a b) 1) is b

Hy ഒരു ഡോട്ട്-ലിസ്റ്റ് വാക്യഘടനയെ പിന്തുണയ്ക്കുന്നു, എവിടെ '(എ . b) അർത്ഥം (ദോഷങ്ങൾ 'a 'b) ഒപ്പം '(എ b . c) അർത്ഥം
(ദോഷങ്ങൾ 'a (ദോഷങ്ങൾ 'b 'സി)). കംപൈലർ മുകളിലെ തലത്തിൽ ഒരു കോൺസ് സെൽ നേരിടുകയാണെങ്കിൽ, അത് ഉയർത്തുന്നു
ഒരു സമാഹാര പിശക്.

ഹൈക്കോൺസ് കൃത്രിമത്വം എളുപ്പമാക്കുന്നതിന്, പാസാക്കിയ ആർഗ്യുമെന്റുകൾ (കാറും സിഡിആർ) ഹൈ തരങ്ങളിൽ പൊതിയുന്നു
ഒരു മാക്രോ സന്ദർഭത്തിലെ കോൻസ് സെല്ലുകൾ.

Hy ആന്തരിക സിദ്ധാന്തം
പൊതു അവലോകനം
ഹൈ ഇന്റേണലുകൾ പൈത്തൺ ബൈറ്റ്കോഡിന്റെ ഫ്രണ്ട് എൻഡ് ആയി പ്രവർത്തിക്കുന്നു, അങ്ങനെ ഹൈ തന്നെ
പൈത്തൺ ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു, ഇത് പരിഷ്ക്കരിക്കാത്ത പൈത്തൺ റൺടൈമിനെ ഹൈ കോഡ് പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു,
അതൊന്നും ശ്രദ്ധിക്കാതെ.

ഹൈ ഒരു ആന്തരിക പൈത്തൺ AST ഡാറ്റാസ്ട്രക്ചറിലേക്ക് വിവർത്തനം ചെയ്യുക എന്നതാണ് ഞങ്ങൾ ഇത് ചെയ്യുന്ന രീതി, കൂടാതെ
പൈത്തൺ സ്റ്റാൻഡേർഡിൽ നിന്നുള്ള മൊഡ്യൂളുകൾ ഉപയോഗിച്ച് പൈത്തൺ ബൈറ്റ്കോഡിലേക്ക് ആ എഎസ്ടി നിർമ്മിക്കുന്നു
ലൈബ്രറി, അതിനാൽ പൈത്തൺ ഇന്റേണലുകളുടെ എല്ലാ പ്രവർത്തനങ്ങളും നമുക്ക് ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യേണ്ടതില്ല.
സിംഗിൾ പൈത്തൺ റിലീസ്.

നാല് ഘട്ടങ്ങളിലായാണ് ഹൈ പ്രവർത്തിക്കുന്നത്. ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ ഉറവിടത്തിൽ നിന്ന് ഹൈയുടെ ഓരോ ഘട്ടവും ഉൾക്കൊള്ളുന്നു
റൺടൈം.

നടപടികൾ 1 ഒപ്പം 2: ടോക്കണിംഗ് ഒപ്പം പാഴ്‌സിംഗ്
ഹൈ കംപൈൽ ചെയ്യുന്നതിന്റെ ആദ്യ ഘട്ടം, നമുക്ക് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ടോക്കണുകളിലേക്ക് ഉറവിടത്തെ ലെക്സ് ചെയ്യുക എന്നതാണ്. ഞങ്ങൾ
rply എന്ന പ്രോജക്റ്റ് ഉപയോഗിക്കുക, അത് ഒരു ഉപവിഭാഗത്തിൽ എഴുതിയിരിക്കുന്ന നല്ല (വേഗതയുള്ള) പാർസറാണ്.
rpython എന്ന പൈത്തണിന്റെ.

ലെക്സിംഗ് കോഡ് എല്ലാം നിർവചിച്ചിരിക്കുന്നു hy.lex.lexer. ഈ കോഡ് കൂടുതലും ഹൈയെ നിർവചിക്കുന്നു
വ്യാകരണം, കൂടാതെ എല്ലാ യഥാർത്ഥ ഹാർഡ് ഭാഗങ്ങളും rply വഴി പരിപാലിക്കപ്പെടുന്നു -- ഞങ്ങൾ നിർവചിക്കുന്നു
റിപ്ലൈ ഇൻ ചെയ്യാനുള്ള "കോൾബാക്കുകൾ" hy.lex.parser, ഇത് ജനറേറ്റ് ചെയ്ത ടോക്കണുകൾ എടുത്ത് തിരികെ നൽകുന്നു
ഹൈ മോഡലുകൾ.

നിങ്ങൾക്ക് Hy മോഡലുകളെ Hy യുടെ "AST" ആയി കണക്കാക്കാം, അതാണ് മാക്രോകൾ പ്രവർത്തിക്കുന്നത്
(നേരിട്ട്), ഹൈ ഡൗൺ കംപൈൽ ചെയ്യുമ്പോൾ കംപൈലർ ഉപയോഗിക്കുന്നത് ഇതാണ്.

കാണുക കൂടാതെ:
വിഭാഗം Hy മോഡലുകൾ ഹൈ മോഡലുകളെക്കുറിച്ചും അവ എന്താണ് അർത്ഥമാക്കുന്നത് എന്നതിനെക്കുറിച്ചും കൂടുതൽ വിവരങ്ങൾക്ക്.

ഘട്ടം 3: Hy സമാഹരണ ലേക്ക് പൈത്തൺ AST
ഹൈയിലെ ഭൂരിഭാഗം മാന്ത്രികതയും ഇവിടെയാണ് സംഭവിക്കുന്നത്. ഇവിടെയാണ് ഞങ്ങൾ Hy AST (മോഡലുകൾ) എടുക്കുന്നത്,
അവ പൈത്തൺ എഎസ്ടിയിലേക്ക് കംപൈൽ ചെയ്യുക. കുറച്ച് കഴിഞ്ഞത് പ്രവർത്തിക്കാൻ രസകരമായ രണ്ട് കാര്യങ്ങൾ ഇവിടെ സംഭവിക്കുന്നു
എഎസ്ടിയിലെ പ്രശ്നങ്ങൾ, കംപൈലറിൽ പ്രവർത്തിക്കുന്നത് ഞങ്ങൾ ചെയ്യുന്ന ഏറ്റവും പ്രധാനപ്പെട്ട ജോലിയാണ്
ഉണ്ട്.

കംപൈലർ അൽപ്പം സങ്കീർണ്ണമാണ്, അതിനാൽ ആദ്യ ഷോട്ടിൽ തന്നെ അത് തട്ടിമാറ്റിയില്ലെങ്കിൽ വിഷമിക്കേണ്ട,
ശരിയാകാൻ കുറച്ച് സമയമെടുത്തേക്കാം.

കമ്പൈലറിലേക്കുള്ള പ്രധാന പ്രവേശന പോയിന്റ് HyASTCompiler.compile. ഈ രീതി അഭ്യർത്ഥിക്കുന്നു, ഒപ്പം
ക്ലാസിലെ ഒരേയൊരു യഥാർത്ഥ "പൊതു" രീതി (അതായത്, ഞങ്ങൾ ശരിക്കും വാഗ്ദാനം ചെയ്യുന്നില്ല
ആ രീതിക്ക് അപ്പുറം API).

വാസ്തവത്തിൽ, ആന്തരികമായി പോലും, ഞങ്ങൾ ഒരിക്കലും നേരിട്ട് ആവർത്തിക്കില്ല, ഞങ്ങൾ മിക്കവാറും എല്ലായ്‌പ്പോഴും നിർബന്ധിക്കുന്നു
ഹൈ ട്രീ വഴി സമാഹരിക്കുക, കൂടാതെ ഇത് പലപ്പോഴും ഒരു പദപ്രയോഗത്തിന്റെ ഉപഘടകങ്ങൾ ഉപയോഗിച്ച് ചെയ്യും
നമുക്കുള്ളത്. ഉപ-ഘടകങ്ങൾ ശരിയായി അയയ്‌ക്കേണ്ടത് തരം അധിഷ്‌ഠിത ഡിസ്‌പാച്ചറിന്റെ ചുമതലയാണ്.

ഒരു സമാഹാരത്തിന് മുമ്പുള്ള എല്ലാ രീതികളും അടയാളപ്പെടുത്തിയിരിക്കുന്നു @ബിൽഡ്സ്() അലങ്കാരപ്പണിക്കാരൻ. നിങ്ങൾക്ക് കഴിയും
ഒന്നുകിൽ അത് കംപൈൽ ചെയ്യുന്ന ഹൈ മോഡലിന്റെ ക്ലാസ്സിൽ വിജയിക്കുക, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗ് ഉപയോഗിക്കാം
ഭാവങ്ങൾ. ഞാൻ ഇത് ഒരു നിമിഷത്തിനുള്ളിൽ മായ്‌ക്കും.

ആദ്യം സ്റ്റേജ് ടൈപ്പ്-ഡിസ്പാച്ച്
ഇതിൽ തുടങ്ങാം സമാഹരിക്കുക രീതി. നമ്മൾ ആദ്യം ചെയ്യുന്നത് വസ്തുവിന്റെ തരം പരിശോധിക്കുകയാണ്
ഞങ്ങൾ പണിയുകയാണ്. നമുക്ക് നിർമ്മിക്കാൻ കഴിയുന്ന ഒരു രീതി ഉണ്ടോ എന്ന് ഞങ്ങൾ നോക്കുന്നു തരം () ഞങ്ങൾ
ഉണ്ട്, അത് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന രീതിയിലേക്ക് അയയ്ക്കുക. ഞങ്ങൾക്ക് ഒരു രീതിയും ഇല്ലെങ്കിൽ അത് സാധിക്കും
ആ തരം നിർമ്മിക്കുക, ഞങ്ങൾ ഒരു ആന്തരികം ഉയർത്തുന്നു ഒഴിവാക്കൽ.

ഉദാഹരണത്തിന്, നമുക്ക് ഒരു ഉണ്ടെങ്കിൽ ഹൈസ്ട്രിംഗ്, ഹൈ എഎസ്ടി മുതൽ പൈത്തൺ വരെയുള്ള 1 മുതൽ 1 വരെയുള്ള മാപ്പിംഗ് ഞങ്ങളുടെ പക്കലുണ്ട്
എ.എസ്.ടി. ദി കംപൈൽ_സ്ട്രിംഗ് രീതി എടുക്കുന്നു ഹൈസ്ട്രിംഗ്, ഒപ്പം റിട്ടേൺസ് ഒരു ast.Str() അതാണ്
ശരിയായ ലൈൻ-നമ്പറുകളും ഉള്ളടക്കവും കൊണ്ട് നിറഞ്ഞിരിക്കുന്നു.

മാക്രോ-വികസിപ്പിക്കുക
നമുക്ക് ഒരു കിട്ടിയാൽ ഹൈഎക്സ്പ്രഷൻ, ഇത് അറിയപ്പെടുന്ന ഒരു മാക്രോ ആണോ എന്ന് നോക്കാൻ ഞങ്ങൾ ശ്രമിക്കും, ഒപ്പം ഉണ്ടായിരിക്കാൻ ശ്രമിക്കും
ആവാഹിച്ചുകൊണ്ട് അത് വികസിച്ചു hy.macros.macroexpand, തുടർന്ന് ഫലം വീണ്ടും അതിലേക്ക് തള്ളുക
HyASTCompiler.compile.

സെക്കന്റ് സ്റ്റേജ് എക്സ്പ്രഷൻ-ഡിസ്പാച്ച്
ഒരേയൊരു പ്രത്യേക കേസ് ആണ് ഹൈഎക്സ്പ്രഷൻ, കാരണം ഞങ്ങൾ വ്യത്യസ്തമായ AST സൃഷ്ടിക്കേണ്ടതുണ്ട്
പ്രത്യേക ഫോമിൽ ഉദാഹരണത്തിന്, ഞങ്ങൾ ഒരു അടിക്കുമ്പോൾ (അങ്ങനെയെങ്കിൽ യഥാർഥ യഥാർഥ തെറ്റായ), ഞങ്ങൾ
ഒരു സൃഷ്ടിക്കേണ്ടതുണ്ട് ast.If, കൂടാതെ ഉപ-നോഡുകൾ ശരിയായി കംപൈൽ ചെയ്യുക. ഇവിടെയാണ് ദി @ബിൽഡ്സ്()
ഒരു സ്ട്രിംഗ് ഉപയോഗിച്ച് ഒരു വാദം വരുന്നു.

വേണ്ടി കംപൈൽ_എക്സ്പ്രഷൻ (അത് കൊണ്ട് നിർവചിച്ചിരിക്കുന്നത് @ബിൽഡ്സ്(ഹൈഎക്സ്പ്രഷൻ)) അയയ്ക്കും
ആദ്യ ആർഗ്യുമെന്റിന്റെ സ്ട്രിംഗ് അടിസ്ഥാനമാക്കി. ചില കാരണങ്ങളാൽ, ആദ്യത്തെ വാദം അങ്ങനെയല്ല
ഒരു സ്ട്രിംഗ്, അത് ആ കേസും ശരിയായി കൈകാര്യം ചെയ്യും (മിക്കവാറും ഒരു ഉയർത്തിക്കൊണ്ട് ഒഴിവാക്കൽ).

സ്‌ട്രിംഗിനെ ഹൈയ്‌ക്ക് അറിയില്ലെങ്കിൽ, അത് സൃഷ്‌ടിക്കുന്നത് ഡിഫോൾട്ടായിരിക്കും ast.വിളിക്കുക, ഏത് ശ്രമിക്കും
ഒരു റൺടൈം കോൾ ചെയ്യുക (പൈത്തണിൽ, ഇതുപോലുള്ള ഒന്ന് foo()).

പ്രശ്നങ്ങൾ തട്ടുക കൂടെ പൈത്തൺ AST
പൈത്തൺ AST മികച്ചതാണ്; അതാണ് ഇത്രയും ശക്തമായ ഒരു പ്രോജക്റ്റ് മുകളിൽ എഴുതാൻ ഞങ്ങളെ പ്രാപ്തമാക്കിയത്
പൈത്തണിനോട് ശക്തമായി പോരാടാതെ പൈത്തൺ. എന്തും പോലെ, ഞങ്ങൾക്ക് ന്യായമായ പങ്കുണ്ട്
പ്രശ്നങ്ങൾ, നിങ്ങൾ നേരിട്ടേക്കാവുന്ന പൊതുവായവയുടെ ഒരു ചെറിയ ലിസ്റ്റ് ഇതാ.

പൈത്തൺ വ്യത്യാസപ്പെടുത്തുന്നു തമ്മിലുള്ള പ്രസ്താവനകൾ ഒപ്പം ഭാവങ്ങൾ.

ഇതൊരു വലിയ കാര്യമായി തോന്നണമെന്നില്ല -- വാസ്തവത്തിൽ, മിക്ക പൈത്തൺ പ്രോഗ്രാമർമാർക്കും ഇത് ചെയ്യും
താമസിയാതെ "ശരി, അതെ" എന്ന നിമിഷമായി.

പൈത്തണിൽ, ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യുന്നു:

അച്ചടിക്കുക വേണ്ടി x in ശ്രേണി(10): കടന്നുപോകുക, കാരണം അച്ചടിക്കുക പ്രിന്റുകൾ എക്സ്പ്രഷനുകൾ, ഒപ്പം വേണ്ടി ഒരു അല്ല
എക്സ്പ്രഷൻ, ഇതൊരു നിയന്ത്രണ ഫ്ലോ പ്രസ്താവനയാണ്. തുടങ്ങിയ കാര്യങ്ങൾ 1 + 1 എക്സ്പ്രഷനുകളാണ്, അതുപോലെ ലാംഡ
x: 1 + x, എന്നാൽ മറ്റ് ഭാഷാ സവിശേഷതകൾ if, വേണ്ടി, അഥവാ സമയത്ത് പ്രസ്താവനകളാണ്.

പൈത്തണിനോട് അവർക്ക് "മൂല്യം" ഇല്ലാത്തതിനാൽ, ഇത് എന്തെങ്കിലും ചെയ്യുന്നത് മുതൽ ഹൈ-യിൽ പ്രവർത്തിക്കുന്നത് കഠിനമാക്കുന്നു
പോലെ (അച്ചടി (അങ്ങനെയെങ്കിൽ യഥാർഥ യഥാർഥ തെറ്റായ)) ഇത് സാധാരണമല്ല, പ്രതീക്ഷിക്കുന്നു.

തൽഫലമായി, a ഉപയോഗിച്ച് ഞങ്ങൾ കാര്യങ്ങൾ സ്വയമേവ മാംഗിൾ ചെയ്യുന്നു ഫലമായി ഒബ്ജക്റ്റ്, ഞങ്ങൾ എന്തെങ്കിലും വാഗ്ദാനം ചെയ്യുന്നിടത്ത് ast.stmt
റൺ നേടേണ്ടതുണ്ട്, ഒരു സിംഗിൾ ast.expr എന്തിന്റെയെങ്കിലും മൂല്യം ലഭിക്കാൻ അത് ഉപയോഗിക്കാം
ഓടുകയായിരുന്നു. ഓടുമ്പോൾ കാര്യങ്ങൾക്ക് അസൈൻമെന്റ് നിർബന്ധിച്ചുകൊണ്ടാണ് Hy ഇത് ചെയ്യുന്നത്.

ഉദാഹരണത്തിന്, ഹൈ:

(അച്ചടിക്കുക (ശരി ശരിയാണെങ്കിൽ തെറ്റ്))

ഇതിലേക്ക് മാറും:

ശരിയാണെങ്കിൽ:
_mangled_name_here = ശരി
വേറെ:
_mangled_name_here = തെറ്റ്

ഇവിടെ _mangled_name_print ചെയ്യുക

ശരി, അതൊരു നുണയായിരുന്നു, കാരണം ഞങ്ങൾ ആ പ്രസ്താവനയെ യഥാർത്ഥത്തിൽ ഇതിലേക്ക് മാറ്റുന്നു:

True else False ആണെങ്കിൽ True എന്ന് പ്രിന്റ് ചെയ്യുക

ഒരു കാര്യത്തിലേക്ക് കാര്യങ്ങൾ നിർബന്ധിച്ച് കൊണ്ട് ast.expr നമുക്ക് കഴിയുമെങ്കിൽ, പക്ഷേ പൊതുവായ ആശയം നിലനിൽക്കുന്നു.

ഘട്ടം 4: പൈത്തൺ ബൈറ്റ്‌കോഡ് ഔട്ട്പുട്ട് ഒപ്പം പ്രവർത്തനസമയം
നമുക്ക് ഒരു പൈത്തൺ AST ട്രീ പൂർത്തിയായ ശേഷം, നമുക്ക് അത് പൈത്തണിലേക്ക് കംപൈൽ ചെയ്യാൻ ശ്രമിക്കാം.
അതിലൂടെ തള്ളിക്കൊണ്ട് ബൈറ്റ്കോഡ് പരിണാമം. ഇവിടെ നിന്ന്, ഞങ്ങൾക്ക് മേലിൽ നിയന്ത്രണമില്ല, ഒപ്പം
പൈത്തൺ എല്ലാം പരിപാലിക്കുന്നു. അതുകൊണ്ടാണ് പൈത്തൺ ട്രേസ്ബാക്കുകൾ, പിഡിബി, തുടങ്ങിയ കാര്യങ്ങൾ
django ആപ്പുകൾ പ്രവർത്തിക്കുന്നു.

Hy മാക്രോകൾ
ഉപയോഗിക്കുന്നു gensym വേണ്ടി സുരക്ഷിതമാക്കുന്നതിന് മാക്രോകൾ
മാക്രോകൾ എഴുതുമ്പോൾ, ബാഹ്യ വേരിയബിളുകൾ ക്യാപ്‌ചർ ചെയ്യുന്നതോ ഉപയോഗിക്കുന്നതോ ഒഴിവാക്കാൻ ശ്രദ്ധിക്കണം
ഉപയോക്തൃ കോഡുമായി വൈരുദ്ധ്യമുള്ള വേരിയബിൾ പേരുകൾ.

ഞങ്ങൾ ഒരു ഉദാഹരണം മാക്രോ ഉപയോഗിക്കും നിഫ് (കാണുക
http://letoverlambda.com/index.cl/guest/chap3.html#സെക്കൻഡ്_5 കൂടുതൽ പൂർണ്ണമായ വിവരണത്തിനായി.)
നിഫ് ഒരു ഉദാഹരണമാണ്, ഒരു സംഖ്യ പോലെയുള്ള ഒന്ന് if, പദപ്രയോഗത്തെ അടിസ്ഥാനമാക്കി, അതിലൊന്ന്
പദപ്രയോഗം പോസിറ്റീവ് ആണോ പൂജ്യമാണോ നെഗറ്റീവ് ആണോ എന്നതിനെ ആശ്രയിച്ച് 3 ഫോമുകൾ വിളിക്കുന്നു.

ആദ്യ പാസ് ഇതുപോലെയായിരിക്കാം:

(defmacro nif [expr pos-form zero-form neg-form]
`([[അവ്യക്ത-നാമം ~expr]]
(കോണ്ട് [(പോസ്? അവ്യക്തമായ പേര്) ~പോസ്-ഫോം]
[(പൂജ്യം? അവ്യക്തമായ പേര്) ~പൂജ്യം-രൂപം]
[(നെഗ്? അവ്യക്തമായ പേര്) ~നെഗ്-ഫോം])))

എവിടെ അവ്യക്തമായ പേര് മറ്റുള്ളവയുമായി വൈരുദ്ധ്യമുണ്ടാകാതിരിക്കാൻ ചില വേരിയബിൾ പേരുകൾ തിരഞ്ഞെടുക്കാനുള്ള ശ്രമമാണ്
കോഡ്. എന്നാൽ തീർച്ചയായും, സദുദ്ദേശ്യമാണെങ്കിലും, ഇത് ഒരു ഉറപ്പുനൽകുന്നില്ല.

അത്തരമൊരു അവസരത്തിനായി ഒരു പുതിയ, അതുല്യമായ ചിഹ്നം സൃഷ്ടിക്കുന്നതിനാണ് ജെൻസിം രീതി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.
വളരെ മികച്ച പതിപ്പ് നിഫ് ആയിരിക്കും:

(defmacro nif [expr pos-form zero-form neg-form]
(ആവട്ടെ [[g (gensym))]]
`([[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(പൂജ്യം? ~g) ~പൂജ്യം-രൂപം]
[(neg? ~g) ~neg-form]))))

ഒരു ചിഹ്നം മാത്രമുള്ളതിനാൽ ഇത് എളുപ്പമുള്ള കാര്യമാണ്. എന്നാൽ നിരവധി ആവശ്യമുണ്ടെങ്കിൽ
gensym's-ന്റെ ഒരു ശ്രേണിയിലേക്ക് അടിസ്ഥാനപരമായി വികസിക്കുന്ന രണ്ടാമത്തെ മാക്രോ വിത്ത്-ജെൻസിംസ് ഉണ്ട് ചെയ്യട്ടെ
പ്രസ്താവനകൾ:

(ജെൻസിംസിനൊപ്പം [abc]
...)

ഇതിലേക്ക് വികസിക്കുന്നു:

(ആവട്ടെ [[a (gensym))
[ബി (ജെൻസിം)
[സി (ജെൻസിം)]]
...)

അതിനാൽ ഞങ്ങൾ വീണ്ടും എഴുതി നിഫ് ഇതുപോലെ കാണപ്പെടും:

(defmacro nif [expr pos-form zero-form neg-form]
(വിത്ത്-ജെൻസിംസ് [g]
`([[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(പൂജ്യം? ~g) ~പൂജ്യം-രൂപം]
[(neg? ~g) ~neg-form]))))

അവസാനമായി, നമുക്കായി ഇതെല്ലാം ചെയ്യുന്ന ഒരു പുതിയ മാക്രോ ഉണ്ടാക്കാമെങ്കിലും. defmacro/g! എടുക്കും
ആരംഭിക്കുന്ന എല്ലാ ചിഹ്നങ്ങളും g! ഓട്ടോമാറ്റിക്കായി വിളിക്കുകയും ചെയ്യുന്നു gensym ബാക്കിയുള്ളവയുമായി
ചിഹ്നം. അങ്ങനെ g!a ആകും (ജെൻസിം "എ").

ഞങ്ങളുടെ അവസാന പതിപ്പ് നിഫ്, ഉപയോഗിച്ച് നിർമ്മിച്ചത് defmacro/g! മാറുന്നു:

(defmacro/g! nif [expr pos-form zero-form neg-form]
`([[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-form]
[(പൂജ്യം? ~g!res) ~പൂജ്യം-രൂപം]
[(neg? ~g!res) ~neg-form]))))

പരിശോധിക്കുന്നു മാക്രോ വാദങ്ങൾ ഒപ്പം വളർത്തുന്നു ഒഴിവാക്കലുകൾ
Hy കംപൈലർ ബിൽറ്റ്-ഇന്നുകൾ

CONTRIBUTOR ഘടകങ്ങൾ INDEX

ഉള്ളടക്കം:

അനാഫോറിക് മാക്രോകൾ
0.9.12 പതിപ്പിൽ പുതിയത്.

അനാഫോറിക് മാക്രോസ് മൊഡ്യൂൾ ഹൈയിലെ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് വളരെ സംക്ഷിപ്തവും എളുപ്പവുമാക്കുന്നു
വായിക്കുക.
ഒരു അനാഫോറിക് മാക്രോ എന്നത് ഒരു തരം പ്രോഗ്രാമിംഗ് മാക്രോ ആണ്, അത് മനപ്പൂർവ്വം ചില രൂപങ്ങൾ പിടിച്ചെടുക്കുന്നു
ഒരു അനാഫോർ പരാമർശിച്ചേക്കാവുന്ന മാക്രോയിലേക്ക് വിതരണം ചെയ്യുന്നു (ഒരു പദപ്രയോഗം പരാമർശിക്കുന്നു
മറ്റൊരാളിലേക്ക്). — വിക്കിപീഡിയ (http://en.wikipedia.org/wiki/Anaphoric_macro)

മാക്രോകൾ
ap-if
ഉപയോഗം: (ap-if (foo) (അച്ചടി അത്))

സത്യത്തിനായുള്ള ആദ്യ രൂപത്തെ വിലയിരുത്തുകയും അതിനെ ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു it സത്യത്തിലും തെറ്റിലും
ശാഖകൾ.

ap-ഓരോന്നും
ഉപയോഗം: (എപി-ഓരോ [1 2 3 4 5] (അച്ചടി അത്))

പാർശ്വഫലങ്ങൾക്കായി പട്ടികയിലെ ഓരോ മൂലകത്തിന്റെയും ഫോം വിലയിരുത്തുക.

ap-ഓരോ സമയത്തും
ഉപയോഗം: (എപി-ഓരോ സമയത്തും പട്ടിക മുൻ ശരീരം)

പ്രവചന ഫോം മടങ്ങിവരുന്ന ഓരോ ഘടകത്തിനും ഫോം വിലയിരുത്തുക ട്രൂ.

=> (ap-each-while [1 2 3 4 5 6] (< it 4) (അത് അച്ചടിക്കുക))
1
2
3

ap-map
ഉപയോഗം: (ap-map രൂപം പട്ടിക)

മാപ്പിന്റെ അനാഫോറിക് രൂപം ഒരു ഫംഗ്‌ഷന് പകരം സാധാരണ മാപ്പ് പോലെ പ്രവർത്തിക്കുന്നു
ഒബ്ജക്റ്റ് ഒരു ഹൈ ഫോം എടുക്കുന്നു. പ്രത്യേക നാമം it എന്നതിൽ നിന്ന് നിലവിലുള്ള വസ്തുവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു
ആവർത്തനത്തിലെ പട്ടിക.

=> (ലിസ്റ്റ് (ap-map (* it 2) [1 2 3]))
[XXX, 2, 4]

ap-map-എപ്പോൾ
ഉപയോഗം: (ap-map-എപ്പോൾ predfn rep പട്ടിക)

എപ്പോൾ പ്രയോഗിക്കണമെന്ന് നിർണ്ണയിക്കാൻ ഒരു പ്രെഡിക്കേറ്റ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ലിസ്റ്റിന് മുകളിലൂടെ ഒരു മാപ്പിംഗ് വിലയിരുത്തുക
രൂപം.

=> (ലിസ്റ്റ് (ap-map-ഓഡ് എപ്പോൾ? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (ലിസ്റ്റ് (ap-map-when even? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-ഫിൽട്ടർ
ഉപയോഗം: (എപി-ഫിൽട്ടർ രൂപം പട്ടിക)

അതുപോലെ ap-map യുടെ മൂലകങ്ങൾ ഫിൽട്ടർ ചെയ്യുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷനു പകരം ഞങ്ങൾ ഒരു പ്രത്യേക ഫോം എടുക്കുന്നു
പട്ടിക. പ്രത്യേക നാമം it ആവർത്തനത്തിലെ നിലവിലെ മൂലകവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

=> (ലിസ്റ്റ് (ap-ഫിൽറ്റർ (> (* അത് 2) 6) [1 2 3 4 5]))
[4, 5]

ap-നിരസിക്കുക
ഉപയോഗം: (എപി-നിരസിക്കുക രൂപം പട്ടിക)

ഈ പ്രവർത്തനം വിപരീതമാണ് ചെയ്യുന്നത് ap-ഫിൽട്ടർ, അത് കടന്നുപോകുന്ന ഘടകങ്ങളെ നിരസിക്കുന്നു
പ്രവചിക്കുക . പ്രത്യേക നാമം it ആവർത്തനത്തിലെ നിലവിലെ മൂലകവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

=> (ലിസ്റ്റ് (ap-reject (> (* it 2) 6) [1 2 3 4 5]))
[XXX, 1, 2]

ap-dotimes
ഉപയോഗം (ap-dotimes n ശരീരം)

ഈ പ്രവർത്തനം ശരീരത്തെ വിലയിരുത്തുന്നു n സമയങ്ങൾ, പ്രത്യേക വേരിയബിൾ ഉപയോഗിച്ച് it നിന്ന് ബന്ധിക്കപ്പെട്ടിരിക്കുന്നു 0 ലേക്ക്
1-എൻ. പാർശ്വഫലങ്ങൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.

=> (setv n [])
=> (ap-dotimes 3 (.അതിൽ ചേർക്കുക))
=> എൻ
[XXX, 0, 1]

എപി-ആദ്യം
ഉപയോഗം (എപി-ആദ്യം predfn പട്ടിക)

ഈ ഫംഗ്‌ഷൻ പ്രവചനം അല്ലെങ്കിൽ കടന്നുപോകുന്ന ആദ്യത്തെ ഘടകം നൽകുന്നു ഒന്നുമില്ലകൂടെ
പ്രത്യേക വേരിയബിൾ it ആവർത്തനത്തിലെ നിലവിലെ മൂലകവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

=>(എപി-ആദ്യം (> അത് 5) (പരിധി 10))
6

ap-അവസാനം
ഉപയോഗം (എപി-അവസാനം predfn പട്ടിക)

ഈ ഫംഗ്‌ഷൻ പ്രവചനം അല്ലെങ്കിൽ അവസാനത്തെ ഘടകം നൽകുന്നു ഒന്നുമില്ല, പ്രത്യേകം കൂടെ
വേരിയബിൾ it ആവർത്തനത്തിലെ നിലവിലെ മൂലകവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

=>(ap-last (> it 5) (പരിധി 10))
9

ap-കുറയ്ക്കുക
ഉപയോഗം (എപി-കുറയ്ക്കുക രൂപം പട്ടിക &ഓപ്ഷണൽ പ്രാരംഭ മൂല്യം)

ഈ ഫംഗ്‌ഷൻ ശരീരത്തിലെ ആദ്യത്തെ 2 ഘടകങ്ങളിലേക്ക് ഫോം പ്രയോഗിക്കുന്നതിന്റെ ഫലം നൽകുന്നു
ലിസ്റ്റ് തീരുന്നത് വരെ ഫലവും മൂന്നാം ഘടകവും പ്രയോഗിക്കുന്നു. ഓപ്ഷണലായി ഒരു
പ്രാരംഭ മൂല്യം നൽകാം, അതിനാൽ ഫംഗ്ഷൻ പ്രാരംഭ മൂല്യത്തിനും ദ്
പകരം ആദ്യ ഘടകം. ഇത് ആവർത്തിച്ചുള്ള മൂലകത്തെ തുറന്നുകാട്ടുന്നു it നിലവിലുള്ളതും
ആയി സഞ്ചിത മൂല്യം ആഗസ്റ്റ്.

=>(ap-reduce (+ it acc) (പരിധി 10))
45

ലൂപ്പ്/ആവർത്തനം
0.10.0 പതിപ്പിൽ പുതിയത്.

ദി ലൂപ്പ് / വീണ്ടും വരുത്തുക മാക്രോ പ്രോഗ്രാമർമാർക്ക് ടെയിൽ-കോൾ ഒപ്റ്റിമൈസേഷൻ (TCO) ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ലളിതമായ മാർഗം നൽകുന്നു
അവരുടെ ഹൈ കോഡിൽ.
ഒരു ടെയിൽ കോൾ എന്നത് ഒരു സബ്റൂട്ടീൻ കോളാണ്, അത് മറ്റൊരു നടപടിക്രമത്തിനുള്ളിൽ അതിന്റെ അന്തിമമായി സംഭവിക്കുന്നു
നടപടി; ഇത് ഒരു റിട്ടേൺ മൂല്യം ഉണ്ടാക്കിയേക്കാം, അത് കോളിംഗ് വഴി ഉടൻ തന്നെ തിരികെ നൽകും
നടപടിക്രമം. ഒരു സബ്റൂട്ടീൻ നടത്തുന്ന ഏതെങ്കിലും കോൾ, അത് ഒടുവിൽ നയിച്ചേക്കാം
ഇതേ സബ്റൂട്ടീനെ കോൾ ചെയിനിലൂടെ വീണ്ടും വിളിക്കുന്നു, അത് ടെയിൽ പൊസിഷനിലാണ്,
അത്തരമൊരു സബ്‌റൂട്ടീൻ ടെയിൽ-റിക്കേഴ്‌സീവ് ആണെന്ന് പറയപ്പെടുന്നു, ഇത് ആവർത്തനത്തിന്റെ ഒരു പ്രത്യേക സാഹചര്യമാണ്.
ഒരു പുതിയ സ്റ്റാക്ക് ചേർക്കാതെ തന്നെ അവ നടപ്പിലാക്കാൻ കഴിയുന്നതിനാൽ ടെയിൽ കോളുകൾക്ക് പ്രാധാന്യമുണ്ട്
കോൾ സ്റ്റാക്കിലേക്കുള്ള ഫ്രെയിം. നിലവിലെ നടപടിക്രമത്തിന്റെ മിക്ക ഫ്രെയിമുകളും ആവശ്യമില്ല
കൂടുതൽ, അത് ടെയിൽ കോളിന്റെ ഫ്രെയിം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം. തുടർന്ന് പ്രോഗ്രാമിന് കുതിക്കാൻ കഴിയും
വിളിക്കപ്പെടുന്ന സബ്റൂട്ടീനിലേക്ക്. ഒരു സ്റ്റാൻഡേർഡ് കോൾ സീക്വൻസിനു പകരം അത്തരം കോഡ് നിർമ്മിക്കുന്നത്
ടെയിൽ കോൾ എലിമിനേഷൻ അല്ലെങ്കിൽ ടെയിൽ കോൾ ഒപ്റ്റിമൈസേഷൻ എന്ന് വിളിക്കുന്നു. ടെയിൽ കോൾ ഒഴിവാക്കൽ അനുവദിക്കുന്നു
ടെയിൽ പൊസിഷനിലുള്ള പ്രൊസീജർ കോളുകൾ ഗോട്ടോ സ്റ്റേറ്റ്‌മെന്റുകൾ പോലെ കാര്യക്ഷമമായി നടപ്പിലാക്കണം,
അങ്ങനെ കാര്യക്ഷമമായ ഘടനാപരമായ പ്രോഗ്രാമിംഗ് അനുവദിക്കുന്നു. — വിക്കിപീഡിയ (-
http://en.wikipedia.org/wiki/Tail_call)

മാക്രോകൾ
ലൂപ്പ്
ലൂപ്പ് ഒരു ആവർത്തന പോയിന്റ് സ്ഥാപിക്കുന്നു. കൂടെ ലൂപ്പ്, വീണ്ടും വരുത്തുക എന്നതിൽ സജ്ജീകരിച്ചിരിക്കുന്ന വേരിയബിളുകൾ റീബൈൻഡ് ചെയ്യുന്നു
ആവർത്തന പോയിന്റ് ആ ആവർത്തന പോയിന്റിലേക്ക് കോഡ് നിർവ്വഹണം തിരികെ അയയ്ക്കുന്നു. എങ്കിൽ വീണ്ടും വരുത്തുക ഉപയോഗിക്കുന്നു
ഒരു നോൺ-ടെയിൽ സ്ഥാനം, ഒരു അപവാദം എറിയപ്പെടുന്നു.

ഉപയോഗം: (ലൂപ്പ് ബൈൻഡിംഗുകൾ &വിശ്രമിക്കുക ശരീരം)

ഉദാഹരണം:

(hy.contrib.loop ആവശ്യമാണ്)

(defn factorial [n]
(ലൂപ്പ് [[ഇൻ] [ac 1]]
(എങ്കിൽ (പൂജ്യം? i)
ആഗസ്റ്റ്
(ആവർത്തനം (ഡിസംബർ i) (* acc i)))))

(ഫാക്ടീരിയൽ 1000)

defmulti
0.10.0 പതിപ്പിൽ പുതിയത്.

defmulti നൽകിയിരിക്കുന്ന ആർഗുകളുടെ കൂടാതെ/അല്ലെങ്കിൽ ക്വാർഗുകളുടെ എണ്ണം അനുസരിച്ച് ഒരു ഫംഗ്‌ഷൻ arity-ഓവർലോഡ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
ക്ലോജൂറിന്റെ പ്രവർത്തനത്തിൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ട് defn.

=> (hy.contrib.multi ആവശ്യമാണ്)
=> (defmulti fun
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (തമാശ 1)
"എ"
=> (തമാശ 1 2)
"ab"
=> (തമാശ 1 2 3)
"abc"

ഹാക്കിംഗ് ON HY

ചേരുക നമ്മുടെ ഹൈവ്!
ദയവായി ഹാക്ക് ഹാക്ക് ചെയ്യുക!

ദയവായി ഞങ്ങളോടൊപ്പം ഹാംഗ് ഔട്ട് ചെയ്യുക #ഹൈ on irc.frenode.net!

ദയവായി ട്വിറ്ററിൽ അതിനെക്കുറിച്ച് സംസാരിക്കുക #ഹൈ ഹാഷ്ടാഗ്!

ദയവായി അതിനെക്കുറിച്ച് ബ്ലോഗ് ചെയ്യുക!

ദയവായി നിങ്ങളുടെ അയൽക്കാരന്റെ വേലിയിൽ ഇത് പെയിന്റ് ചെയ്യരുത് (നന്നായി ചോദിക്കാതെ)!

ഹാക്ക്!
ഇതു ചെയ്യാൻ:

1. സൃഷ്ടിക്കുക വെർച്വൽ പരിസ്ഥിതി:

$ virtualenv venv

അത് സജീവമാക്കുക:

$ venv/bin/activate

അല്ലെങ്കിൽ ഉപയോഗിക്കുക virtualenvwrapper നിങ്ങളുടെ വെർച്വൽ എൻവയോൺമെന്റ് സൃഷ്ടിക്കുന്നതിനും നിയന്ത്രിക്കുന്നതിനും:

$ mkvirtualenv ഹൈ
$ പണിയുണ്ട്

2. സോഴ്സ് കോഡ് നേടുക:

$ git ക്ലോൺ https://github.com/hylang/hy.git

അല്ലെങ്കിൽ നിങ്ങളുടെ നാൽക്കവല ഉപയോഗിക്കുക:

$ git ക്ലോൺ [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]: /hy.git

3. ഹാക്കിംഗിനായി ഇൻസ്റ്റാൾ ചെയ്യുക:

$ cd hy/
$ പിപ്പ് ഇൻസ്റ്റാൾ -ഇ .

4. മറ്റ് ഡെവലപ്പ്-വൈ ആവശ്യകതകൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

$ പിപ്പ് ഇൻസ്റ്റാൾ -r ആവശ്യകതകൾ-dev.txt

5. ആകർഷണീയമായ കാര്യങ്ങൾ ചെയ്യുക; നിങ്ങൾ ചെയ്‌തതിൽ ആരെയെങ്കിലും സന്തോഷത്തോടെ/വെറുപ്പോടെ നിലവിളിക്കുക.

പരീക്ഷിക്കുക!
ടെസ്റ്റുകൾ സ്ഥിതി ചെയ്യുന്നത് പരിശോധനകൾ/. ഞങ്ങൾ ഉപയോഗിക്കുന്നു മൂക്ക്.

പരിശോധനകൾ നടത്തുന്നതിന്:

$ നോസെറ്റസ്റ്റുകൾ

ടെസ്റ്റുകൾ എഴുതുക --- ടെസ്റ്റുകൾ നല്ലതാണ്!

കൂടാതെ, പിന്തുണയ്‌ക്കുന്ന എല്ലാ പ്ലാറ്റ്‌ഫോമുകൾക്കും PEP 8 അനുസരിച്ചുള്ള ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നത് നല്ലതാണ്
കോഡ്. ടോക്സ് പ്രവർത്തിപ്പിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും:

$ ടോക്സ്

പ്രമാണം!
ഡോക്യുമെന്റേഷൻ സ്ഥിതി ചെയ്യുന്നത് ഡോക്‌സ്/. ഞങ്ങൾ ഉപയോഗിക്കുന്നു സ്ഫിംക്സ്.

HTML-ൽ ഡോക്‌സ് നിർമ്മിക്കുന്നതിന്:

$ cd ഡോക്‌സ്
$ html ഉണ്ടാക്കുക

ഡോക്സ് എഴുതുക --- ഡോക്സ് നല്ലതാണ്! ഈ ഡോക്‌ടർ പോലും!

സംഭാവന ചെയ്യുന്നു
സംഭാവനകൾ സ്വാഗതം ചെയ്യുന്നു & വളരെയധികം വിലമതിക്കുന്നു, ഓരോ ചെറിയ കാര്യവും ഹൈയെ കൂടുതൽ ആക്കുന്നതിന് സഹായിക്കുന്നു
ആകർഷകമാണ്.

പുൾ അഭ്യർത്ഥനകൾ മികച്ചതാണ്! ഞങ്ങൾ അവരെ സ്നേഹിക്കുന്നു; ഇതാ ഒരു ദ്രുത ഗൈഡ്:

· റിപ്പോ ഫോർക്ക് ചെയ്ത് ഒരു ഫീച്ചർ/ഫിക്സിനായി ഒരു വിഷയ ശാഖ സൃഷ്ടിക്കുക. നേരിട്ട് മാറ്റങ്ങൾ വരുത്തുന്നത് ഒഴിവാക്കുക
മാസ്റ്റർ ബ്രാഞ്ചിൽ.

· എല്ലാ ഇൻകമിംഗ് ഫീച്ചറുകളും ടെസ്റ്റുകൾക്കൊപ്പം ഉണ്ടായിരിക്കണം.

· നിങ്ങൾ ഒരു പിആർ സമർപ്പിക്കുന്നതിന് മുമ്പ്, ടെസ്റ്റുകൾ റൺ ചെയ്ത് നിങ്ങളുടെ കോഡ് ശൈലിയിൽ പരിശോധിക്കുക
വഴികാട്ടി. നിങ്ങൾക്ക് ഈ രണ്ട് കാര്യങ്ങളും ഒരേസമയം ചെയ്യാൻ കഴിയും:

$ ഉണ്ടാക്കുക ഡി

· കമ്മിറ്റുകൾ ലോജിക്കൽ യൂണിറ്റുകളാക്കി മാറ്റുക, അതുവഴി പിന്നീട് ട്രാക്ക് ചെയ്യാനും നാവിഗേറ്റ് ചെയ്യാനും എളുപ്പമാണ്. മുമ്പ്
ഒരു പിആർ സമർപ്പിക്കുന്നു, തിരികെ വരാൻ എളുപ്പമുള്ള മാറ്റങ്ങളാക്കി കമ്മിറ്റ് ചെയ്യാൻ ശ്രമിക്കുക
പിന്നീട്. കൂടാതെ, മാറ്റങ്ങളിൽ നിങ്ങൾ വ്യാജ വൈറ്റ്‌സ്‌പെയ്‌സ് ഇടുന്നില്ലെന്ന് ഉറപ്പാക്കുക; ഈ
വൈറ്റ്‌സ്‌പേസ് ഫിക്സ് കമ്മിറ്റ് പിന്നീട് സൃഷ്ടിക്കുന്നത് ഒഴിവാക്കുന്നു.

· കമ്മിറ്റ് സന്ദേശങ്ങൾ പോകുന്നിടത്തോളം, ഇനിപ്പറയുന്നവ പാലിക്കാൻ ശ്രമിക്കുക:

Git കമ്മിറ്റ് സന്ദേശങ്ങളുടെ ആദ്യ വരിയിൽ 50 പ്രതീക പരിധിയിൽ ഉറച്ചുനിൽക്കാൻ ശ്രമിക്കുക.

· കൂടുതൽ വിശദാംശങ്ങൾ/വിശദീകരണങ്ങൾക്കായി, ഒരു ശൂന്യമായ വരി ഉപയോഗിച്ച് ഇത് പിന്തുടരുക, തുടരുക
പ്രതിബദ്ധത വിശദമായി വിവരിക്കുന്നു.

അവസാനമായി, സ്വയം AUTHORS ഫയലിലേക്ക് ചേർക്കുക (ഒരു പ്രത്യേക പ്രതിബദ്ധത എന്ന നിലയിൽ): നിങ്ങൾ അത് അർഹിക്കുന്നു :)

· എല്ലാ ഇൻകമിംഗ് മാറ്റങ്ങളും ഹൈലാങ്ങിന്റെ കോർ ടീമിലെ 2 വ്യത്യസ്ത അംഗങ്ങൾ അക് ചെയ്യേണ്ടതുണ്ട്.
അധിക അവലോകനം വ്യക്തമായി സ്വാഗതം ചെയ്യുന്നു, എന്നാൽ ഏതിനും ഞങ്ങൾക്ക് കുറഞ്ഞത് 2 സൈൻഓഫുകൾ ആവശ്യമാണ്
മാറ്റം.

ഒരു പ്രധാന അംഗം PR അയയ്‌ക്കുകയാണെങ്കിൽ, അതിൽ ഉൾപ്പെടാത്ത 2 പ്രധാന അംഗങ്ങളെ കണ്ടെത്തുക
PR സമർപ്പിക്കുന്നയാൾ. ഇവിടെയുള്ള ആശയം ഒരാൾക്ക് പിആർ രചയിതാവിനൊപ്പം പ്രവർത്തിക്കാം, രണ്ടാമത്തേതിന് പ്രവർത്തിക്കാം
മുഴുവൻ മാറ്റ സെറ്റും.

ഡോക്യുമെന്റേഷനും മറ്റ് നിസ്സാരമായ മാറ്റങ്ങൾക്കും, ഒരു ACK-ന് ശേഷം ലയിപ്പിക്കുന്നത് നല്ലതാണ്. ഞങ്ങൾക്ക് കിട്ടി
കുറഞ്ഞ കവറേജ്, അതിനാൽ ആ തടസ്സം കുറയ്ക്കുന്നത് വളരെ നല്ലതാണ്.

കോർ ടീം
ഹൈയുടെ പ്രധാന വികസന ടീം ഇനിപ്പറയുന്ന ഡവലപ്പർമാരാണ്:

· ജൂലിയൻ ഡാൻജ ou

· മോർട്ടൻ ലിൻഡറുഡ്

· J കെന്നത്ത് രാജാവ്

· ഗെർഗെലി നാഗി

· ടുക്ക ടർട്ടോ

· കാരെൻ റസ്താദ്

· അഭിഷേക് L

· ക്രിസ്റ്റഫർ അലൻ വെബർ

· കോൺറാഡ് ഹിൻസൻ

· വിൽപത്രം കാൻ-ഗ്രീൻ

· പൗലോസ് ടാഗ്ലിയമോണ്ടെ

· നിക്കോളാസ് ഡാൻഡ്രിമോണ്ട്

· ബോബ് ടോൾബെർട്ട്

· ബെർക്കർ പെക്സാഗ്

· ക്ലിന്റൺ N. ഡ്രെയിസ്ബാക്ക്

· ഉണ്ട് സെമാജ്

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് hy ഓൺലൈനായി ഉപയോഗിക്കുക