hy - מקוון בענן

תָכְנִית:

שֵׁם

hy - hy תיעוד [תמונה: היי] [תמונה]

לנסות Hy https://try-hy.appspot.com

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

מָקוֹר https://github.com/hylang/hy

רשימה hylang-לדון

IRC #היי על Freenode

לִבנוֹת מצב
טראוויס CI.UNIDENT

Hy הוא ניב נפלא של Lisp שמוטבע ב-Python.

מאז Hy הופך את קוד ה-Lisp שלו לעץ התחביר המופשט של Python, יש לך
כל העולם היפה של פייתון בקצות אצבעותיך, בצורת Lisp!

תוכן:

התחלה מהירה

[תמונה: החיבוקים של קארן רוסטרד] [תמונה]

(תודה לקארן רוסטאד על החיבוקים!)

איך ל לקבל HY נדל"ן מהר:

1. ליצור וירטואלי פיתון סביבה.

2. הפעל את סביבת הפייתון הווירטואלית שלך.

3. התקן hy החל מ- PyPI עם פְּעִים להתקין hy.

4. התחל REPL עם hy.

5. הקלד דברים ב-REPL:

=> (הדפס "היי!")
היי!
=> (defn salutationsnm [שם] (הדפס (+ "Hy " name "!")))
=> (סלutationsnm "שמך")
היי השם שלך!

וכו '

6. לחץ על CTRL-D כשתסיים.

אוומייגוד! זה מדהים! I רוצה ל לכתוב a Hy תכנית.

7. פתח עורך תכנות עילית והקלד:

(הדפס "התכוונתי לקודד בתחביר Python, אבל אז קיבלתי Hy.")

8. שמור בשם מדהים.היי.

9. והפעל את תוכנית Hy הראשונה שלך:

היי מדהים.היי

10.
קח נשימה עמוקה כדי לא להתאוורר יתר על המידה.

11.
חייך ברשע ותתגנב אל המתחם שלך ועשה דברים שלא יתוארו.

הדרכה

ברוכים הבאים להדרכה של Hy!

בקצרה, Hy הוא ניב ליספ, אבל כזה שממיר את המבנה שלו לפייתון...
ממש המרה לעץ התחביר המופשט של Python! (או לשים את זה יותר גס
מונחים, Hy הוא ליספסטיק על פייתון!)

זה די מגניב כי זה אומר שה-Hy הוא כמה דברים:

· Lisp שמרגיש מאוד פייתוני

· עבור Lispers, דרך מצוינת להשתמש בכוחות המטורפים של Lisp אבל בעולם הרחב של Python's
ספריות (למה כן, עכשיו אתה יכול לכתוב יישום Django בליספ!)

· עבור Pythonistas, דרך מצוינת להתחיל לחקור את Lisp, מהנוחות של Python!

· לכולם: שפה נעימה שיש בה הרבה רעיונות מסודרים!

בסיסי intro ל לְשַׂפתֵת ל פיתוניסטות
אוקיי, אולי מעולם לא השתמשת ב-Lisp לפני כן, אבל השתמשת ב-Python!

תוכנית "שלום עולם" ב-Hy היא למעשה סופר פשוטה. בואו ננסה את זה:

(הדפס "שלום עולם")

לִרְאוֹת? קַל! כפי שאולי ניחשתם, זה זהה לגרסת Python של:

הדפס "שלום עולם"

כדי להוסיף קצת מתמטיקה סופר פשוטה, נוכל לעשות:

(+ 1 3)

מה שיחזיר 4 ויהיה שווה ערך ל:

1 + 3

מה שתבחין הוא שהפריט הראשון ברשימה הוא הפונקציה שנקראת וה-
שאר הטיעונים הם הטיעונים שמועברים פנימה. למעשה, ב-Hy (כמו ברוב
Lisps) נוכל להעביר בכמה ארגומנטים לאופרטור הפלוס:

(+ 1 3 55)

מה שיחזיר 59.

אולי שמעתם על ליספ בעבר אבל לא יודעים הרבה על זה. ליספ לא קשה כמוך
יכול לחשוב, ו-Hy יורש מ-Python, אז Hy היא דרך מצוינת להתחיל ללמוד את Lisp.
הדבר העיקרי שברור לגבי ליספ הוא שיש הרבה סוגריים. זה עלול
נראה מבלבל בהתחלה, אבל זה לא כל כך קשה. בואו נסתכל על מתמטיקה פשוטה
עטוף בחבורה של סוגריים שנוכל להזין לתוך המתורגמן Hy:

(תוצאת setv (- (/ (+ 1 3 88) 2) 8))

זה יחזיר 38. אבל למה? ובכן, נוכל להסתכל על הביטוי המקביל ב
פִּיתוֹן:

תוצאה = ((1 + 3 + 88) / 2) - 8

אם היית מנסה להבין איך האמור לעיל יעבוד ב-python, כמובן
להבין את התוצאות על ידי פתרון כל סוגריים פנימיים. זה אותו רעיון בסיסי ב
היי. בואו ננסה תחילה את התרגיל הזה ב- Python:

תוצאה = ((1 + 3 + 88) / 2) - 8
# מפושט ל...
תוצאה = (92 / 2) - 8
# מפושט ל...
תוצאה = 46 - 8
# מפושט ל...
תוצאה = 38

עכשיו בואו ננסה את אותו הדבר ב-Hy:

(תוצאת setv (- (/ (+ 1 3 88) 2) 8))
; מפושט ל...
(תוצאת setv (- (/ 92 2) 8))
; מפושט ל...
(תוצאת טלוויזיה (- 46 8))
; מפושט ל...
(תוצאת סט 38)

כפי שבטח ניחשתם, הביטוי האחרון הזה עם setv פירושו להקצות את המשתנה
"תוצאה" ל-38.

לִרְאוֹת? לא קשה מדי!

זו הנחת היסוד של ליספ. Lisp מייצג "עיבוד רשימה"; זה אומר שה
מבנה התוכנית הוא למעשה רשימות של רשימות. (אם אתה מכיר את Python
רשימות, דמיינו את כל אותו המבנה כמו לעיל אבל עם סוגריים מרובעים במקום, כל
תוכל לראות את המבנה למעלה כתוכנית וגם כמבנה נתונים.) זהו
קל יותר להבנה עם דוגמאות נוספות, אז בואו נכתוב תוכנית Python פשוטה, נבדוק אותה,
ולאחר מכן הצג את תוכנית Hy המקבילה:

def simple_conversation():
הדפס "שלום! הייתי רוצה להכיר אותך. ספר לי על עצמך!"
name = raw_input("מה שמך?")
age = raw_input("מה הגיל שלך? ")
הדפס "שלום " + שם + "! אני רואה שאתה בן " + גיל + " שנים."

simple_conversation()

אם נריץ את התוכנית הזו, זה עשוי להיראות כך:

שלום! אני אשמח להכיר אותך. ספר לי על עצמך!
מה השם שלך? גארי
מה הגיל שלך? 38
שלום גארי! אני רואה שאתה בן 38.

עכשיו בואו נסתכל על תוכנית Hy המקבילה:

(בגדר שיחה פשוטה []
(הדפס "שלום! אני רוצה להכיר אותך. ספר לי על עצמך!")
(שם setv (קלט גולמי "מה שמך?"))
(גיל setv (קלט גולמי "מה הגיל שלך?"))
(הדפס (+ "שלום " שם "! אני רואה שאתה "
גיל "שנים.")))

(שיחה פשוטה)

אם אתה מסתכל על התוכנית לעיל, כל עוד אתה זוכר את האלמנט הראשון בכל אחד
רשימה של התוכנית היא הפונקציה (או המאקרו... נגיע לאלו בהמשך) הנקראת
ושהשאר הם הטיעונים, די קל להבין מה כל זה אומר.
(כמו שבטח גם ניחשתם, defn היא שיטת Hy להגדרת שיטות.)

ובכל זאת, הרבה אנשים מוצאים את זה מבלבל בהתחלה כי יש כל כך הרבה סוגריים,
אבל יש הרבה דברים שיכולים לעזור לעשות את זה יותר קל: לשמור על הזחה יפה ו
השתמש בעורך עם התאמת סוגריים (זה יעזור לך להבין מה כל אחד מהם
סוגריים משתלבים עם) והדברים יתחילו להרגיש בנוח.

יש כמה יתרונות למבנה קוד שהוא למעשה נתונים פשוטים מאוד
מבנה שעליו מתבססת הליבה של Lisp. ראשית, זה אומר שהתוכניות שלך כן
קל לנתח ושכל המבנה בפועל של התוכנית חשוף בצורה ברורה מאוד
לך. (יש שלב נוסף ב-hy שבו המבנה שאתה רואה מומר ל-Python
ייצוגים משלו ... בליספים "טהורים" יותר כגון Common Lisp או Emacs Lisp, הנתונים
מבנה שאתה רואה בקוד ומבנה הנתונים שמבוצע הוא הרבה יותר
ממש קרוב.)

השלכה נוספת לכך היא פקודות מאקרו: אם המבנה של תוכנית הוא נתונים פשוטים
מבנה, זה אומר שאתה יכול לכתוב קוד שיכול לכתוב קוד בקלות רבה, כלומר
יישום תכונות שפה חדשות לגמרי יכול להיות מהיר מאוד. לפני Hy, זה לא היה
אפשרי מאוד עבור מתכנתי Python... עכשיו גם אתה יכול לעשות שימוש בפקודות מאקרו מדהימות
כוח (רק היזהרו לא לכוון אותם קדימה)!

Hy is a בטעם ליספ פיתון
Hy ממיר לעץ התחביר המופשט של Python עצמו, אז בקרוב תתחיל למצוא את זה הכל
הכוח המוכר של פיתון נמצא בהישג ידך.

יש לך גישה מלאה לסוגי הנתונים של Python ולספרייה הסטנדרטית ב-Hy. בואו להתנסות
עם זה ב-hy המתורגמן:

=> [1 2 3]
[1, 2, 3]
=> {"כלב" "נביחה"
... "חתול" "מיאו"}
...
{'dog': 'bark', 'cat': 'meow'}
=> (, 1 2 3)
(1, 2, 3)

אם אתה מכיר ליספים אחרים, אולי יעניין אותך כי Hy תומך ב-Common
שיטת ציטוט ליספ:

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

יש לך גם גישה לכל השיטות הנחמדות של הסוגים המובנים:

=> (.strip " fooooo ")
"פוווו"

מה זה? אכן, זה בדיוק כמו:

"fooooo ".strip()

נכון --- ליספ עם סימון נקודות! אם המחרוזת הזו מוקצית כמשתנה, אנחנו
יכול גם לעשות את הפעולות הבאות:

(setv המחרוזת הזו " fooooo ")
(this-string.strip)

מה לגבי תנאים?:

(אם (נסה-משהו)
(הדפס "זה אם נכון")
(הדפס "זה אם שקר"))

כפי שאתה יכול לומר לעיל, הטיעון הראשון ל if הוא מבחן אמת, הטיעון השני הוא
הגוף אם נכון, והטיעון השלישי (אופציונלי!) הוא אם שקר (כלומר. אחר).

אם אתה צריך לעשות תנאים מורכבים יותר, תגלה שאין לך אליף
זמין ב-Hy. במקום זאת, עליך להשתמש במשהו שנקרא תנאי. ב-Python, אולי תעשה זאת
משהו כמו:

somevar = 33
אם משהו > 50:
הדפס "המשתנה הזה גדול מדי!"
elif somevar < 10:
הדפס "המשתנה הזה קטן מדי!"
else
הדפס "המשתנה הזה הוא פשוט נכון!"

ב-Hy, היית עושה:

(ת
[(> somevar 50)
(הדפס "המשתנה הזה גדול מדי!")]
[(< somevar 10)
(הדפס "המשתנה הזה קטן מדי!")]
[נָכוֹן
(הדפס "המשתנה הזה הוא פשוט נכון!")])

מה שתבחין זה תנאי מכבה בין משפט כלשהו שמתבצע לבין
נבדק באופן מותנה עבור אמת או שקר, ולאחר מכן מעט קוד לביצוע אם הוא מסתובב
החוצה להיות אמיתי. אתה גם שם לב שה אחר מיושם בסוף פשוט על ידי
בודק נָכוֹן -- זה בגלל נָכוֹן תמיד יהיה נכון, אז אם נגיע עד הלום, נגיע
תמיד להפעיל את זה!

אולי תשים לב למעלה שאם יש לך קוד כמו:

(אם תנאי כלשהו
(גוף-אם-נכון)
(גוף-אם-שקר))

אבל חכה! מה אם אתה רוצה לבצע יותר מהצהרה אחת בגוף של אחד מהם
אלה?

תוכל לבצע את הפעולות הבאות:

(אם (נסה-משהו)
(לַעֲשׂוֹת
(הדפס "זה אם נכון")
(הדפס "ולמה לא, בוא נמשיך לדבר על כמה שזה נכון!))
(הדפס "זה עדיין פשוט שקר"))

אתה יכול לראות שהשתמשנו do לעטוף מספר הצהרות. אם אתה מכיר אחרים
ליספס, זה המקביל ל progn במקום אחר.

הערות מתחילות בנקודה-פסיק:

(הדפס "זה ירוץ")
; (הדפס "אבל זה לא יהיה")
(+ 1 2 3); אנחנו נבצע את התוספת, אבל לא את ההערה הזו!

לולאה לא קשה אבל יש לה סוג של מבנה מיוחד. ב-Python, אנו עשויים לעשות:

עבור אני ב רכס(10):
הדפס "'i' נמצא כעת ב-" + str(i)

המקבילה ב-Hy תהיה:

(עבור [i (טווח 10)]
(הדפס (+ "'i' נמצא כעת ב" (str i))))

אתה יכול גם לייבא ולעשות שימוש בספריות Python שונות. לדוגמה:

(ייבוא ​​מערכת הפעלה)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(הדפס "היי, השביל הזה לא שם!"))

מנהלי ההקשרים של פייתון (עם הצהרות) משמשות כך:

(עם [[f (פתח "/tmp/data.in")]]
(הדפס (.read f)))

שווה ערך ל:

עם open("/tmp/data.in") בתור f:
print f.read()

וכן, יש לנו הבנת רשימה! ב-Python אתה עשוי לעשות:

odds_squared = [
pow(num, 2)
עבור num in רכס(100)
אם מספר % 2 == 1]

ב-Hy, אתה יכול לעשות את זה כמו:

(ב-setv odds-squared
(רשימות-קומפ
(פאו מספר 2)
(מספר (טווח 100))
(= (% מספר 2) 1)))

; ודוגמה שנגנבה ללא בושה מדף Clojure:
; בואו נרשום את כל הבלוקים של לוח שחמט:

(רשימות-קומפ
(, xy)
(x (טווח 8)
y "ABCDEFGH"))

; [(0, 'A'), (0, 'B'), (0, 'C'), (0, 'D'), (0, 'E'), (0, 'F'), ( 0, 'G'), (0, 'H'),
; (1, 'A'), (1, 'B'), (1, 'C'), (1, 'D'), (1, 'E'), (1, 'F'), (1 , 'G'), (1, 'H'),
; (2, 'A'), (2, 'B'), (2, 'C'), (2, 'D'), (2, 'E'), (2, 'F'), (2 , 'G'), (2, 'H'),
; (3, 'A'), (3, 'B'), (3, 'C'), (3, 'D'), (3, 'E'), (3, 'F'), (3 , 'G'), (3, 'H'),
; (4, 'A'), (4, 'B'), (4, 'C'), (4, 'D'), (4, 'E'), (4, 'F'), (4 , 'G'), (4, 'H'),
; (5, 'A'), (5, 'B'), (5, 'C'), (5, 'D'), (5, 'E'), (5, 'F'), (5 , 'G'), (5, 'H'),
; (6, 'A'), (6, 'B'), (6, 'C'), (6, 'D'), (6, 'E'), (6, 'F'), (6 , 'G'), (6, 'H'),
; (7, 'A'), (7, 'B'), (7, 'C'), (7, 'D'), (7, 'E'), (7, 'F'), (7 , 'G'), (7, 'H')]

לפייתון יש תמיכה במגוון טיעונים מפוארים ומילות מפתח. בפייתון אולי
ראה:

>>> def optional_arg(pos1, pos2, keyword1=None, keyword2=42):
... return [pos1, pos2, keyword1, keyword2]
...
>>> 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 keyword1 keyword2])
=> (אופציונלי-arg 1 2)
[1 2 אין 42]
=> (אופציונלי-arg 1 2 3 4)
[1 2 3 4]

אם אתה מפעיל גרסה של Hy שעברה 0.10.1 (למשל, git master), יש גם גרסה חדשה ויפה
תחביר ארגומנט מילות מפתח:

=> (אופציונלי-arg :מילת מפתח1 1
... :pos2 2
... :pos1 3
... :מילת מפתח2 4)
[3, 2, 1, 4]

אחרת, אתה תמיד יכול להשתמש להגיש מועמדות. אבל מה כן להגיש מועמדות?

האם אתה מכיר את המעבר *טיעונים ו ** kwargs בפייתון?:

>>> args = [1 2]
>>> kwargs = {"מילת מפתח2": 3
... "מילת מפתח1": 4}
>>> optional_arg(*args, **kwargs)

אנחנו יכולים לשחזר את זה עם להגיש מועמדות:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "מילת מפתח1" 4})
=> (החל את optional-arg args kwargs)
[1, 2, 4, 3]

יש גם מבנה ארגומנטים של מילות מפתח בסגנון מילון שנראה כך:

(הגדר סגנון אחר [&מפתח {"key1" "val1" "key2" "val2"}]
[key1 key2])

ההבדל כאן הוא שמכיוון שזה מילון, אתה לא יכול להסתמך על משהו ספציפי
סדר לטיעונים.

Hy גם תומך *טיעונים ו ** kwargs. בפייתון:

def some_func(foo, bar, *args, **kwargs):
ייבוא ​​הדפסה
pprint.pprint((foo, bar, args, kwargs))

המקבילה Hy:

(הגדיר some-func [foo bar &rest args &kwargs kwargs]
(ייבוא ​​הדפסה)
(pprint.pprint (, foo bar args kwargs)))

לבסוף, כמובן שאנחנו צריכים שיעורים! ב-Python, ייתכן שיהיה לנו מחלקה כמו:

class FooBar(object):
"" "
עוד כיתה לדוגמה
"" "
def __init__(עצמי, x):
self.x = x

def get_x(self):
"" "
החזר את העותק שלנו של x
"" "
החזר עצמי.x

ב-Hy:

(defclass FooBar [object]
"עוד כיתה לדוגמה"
[[--init--
(fn [עצמי x]
(setv self.xx)
; דרוש כרגע עבור --init-- כי __init__ צריך None
; מקווה שזה יעבור :)
אף אחד)]

[קבל-x
(fn [עצמי]
"החזר את העותק שלנו של x"
self.x)]])

אתה יכול גם לעשות תכונות ברמת הכיתה. בפייתון:

class Customer(models.Model):
name = models.CharField(max_length=255)
כתובת = models.TextField()
notes = models.TextField()

ב-Hy:

(defclass Customer [models.Model]
[[שם (models.CharField :max-length 255})]
[כתובת (models.TextField)]
[הערות (models.TextField)]])

Hy <-> פיתון אינטרופ
על ידי ייבוא ​​Hy, אתה יכול להשתמש ב-Hy ישירות מ-Python!

אם תשמור את הדברים הבאים ב ברכות.היי:

(בגדר ברכה [שם] (הדפס "שלום מאת hy," שם))

לאחר מכן תוכל להשתמש בו ישירות מ-python, על ידי ייבוא ​​hy לפני ייבוא ​​המודול. ב
פִּיתוֹן:

ייבוא ​​הי
יבוא ברכות

greetings.greet("פו")

אתה יכול גם להכריז על פונקציה ב-python (או אפילו מחלקה!) ולהשתמש בה ב-Hy!

אם תשמור את הדברים הבאים ב greetings.py בפייתון:

def greet (שם):
print("שלום, %s" % (שם))

אתה יכול להשתמש בו ב-Hy:

(ייבוא ​​ברכות)
(.greet greetings "פו")

כדי להשתמש בארגומנטים של מילות מפתח, אתה יכול להשתמש ב- greetings.py:

def greet(name, title="Sir"):
print("ברכות, %s %s" % (כותרת,שם))

(ייבוא ​​ברכות)
(.ברכות שלום "פו")
(.ברכות שלום "פו" "דארט")
(החל (. greetings greet) ["Foo"] {"title" "Lord"})

מה יפיק:

שלום רב, סר פו

שלום, דארת' פו

שלום רב, לורד פו

פרוטיפים!
Hy כולל גם משהו המכונה "מאקרו השחלה", תכונה ממש מסודרת של
של קלוז'ור. "מאקרו השחלה" (נכתב בשם ->) משמש כדי למנוע קינון עמוק של
ביטויים.

מאקרו השרשור מוסיף כל ביטוי לארגומנט הראשון של הביטוי הבא
במקום.

ניקח את הקלאסי:

(לולאה (הדפס (eval (קריאה)))))

במקום לכתוב את זה ככה, אנחנו יכולים לכתוב את זה בצורה הבאה:

(-> (קריאה) (eval) (הדפסה) (לולאה))

עכשיו, באמצעות פיתון-ש, נוכל להראות כיצד מאקרו השרשור (בגלל ההגדרה של python-sh)
יכול לשמש כמו צינור:

=> (יבא [sh [cat grep wc]])
=> (-> (cat "/usr/share/dict/words") (grep "-E" "^hy") (wc "-l"))
210

מה שכמובן מתרחב ל:

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

הרבה יותר קריא, לא? השתמש במאקרו השרשור!

HY סגנון מדריך

"אתה יודע, השר, אני לא מסכים עם דמבלדור בהרבה סעיפים... אבל אתה לא יכול להכחיש שהוא
יש סטייל..." - פיניאס נייגלוס בלאק, הארי קדר ו מה היא הזמן of מה היא פניקס

המדריך בסגנון Hy מתכוון להיות מערכת כללי יסוד עבור Hyve (כן, קהילת Hy
מתגאה בהוספת Hy לכל דבר) כדי לכתוב קוד Hy אידיומטי. היי מפיק הרבה
מ- Clojure & Common Lisp, תוך שמירה על יכולת פעולה הדדית של Python.

תקדם
אל האני טאו of Hy
אוממון שאל את הנזיר הראשי, "על איזו סוטרה אתה מרצה?"
"סוטרה של נירוונה".
"לסוטרה של נירוונה יש את ארבע המעלות, לא?"
"יש לזה."
שאל אוממון והרים כוס, "כמה מעלות יש לזה?"
"אין בכלל," אמר הנזיר.
"אבל אנשים עתיקים אמרו שכן, לא?" אמר אוממון.
"מה אתה חושב על מה שהם אמרו?"
אוממון היכה בכוס ושאל: "אתה מבין?"
"לא," אמר הנזיר.
"אם כך," אמר אוממון, "כדאי שתמשיך עם ההרצאות שלך על הסוטרה."
- המאקרו (קואן).

להלן ממחישה רשימה קצרה של החלטות עיצוב שנכנסו לביצוע
היי.

· נראה כמו ליספ; DTRT עם זה (למשל מקפים הופכים לקוים תחתונים, אטמי אוזניים הופכים ל
הכול באותיות גדולות).

· אנחנו עדיין פייתון. רוב החלקים הפנימיים מתרגמים 1:1 לפנימיות של Python.

· השתמש ב-Unicode בכל מקום.

· תקן את ההחלטות הרעות ב- Python 2 כשנוכל (ראה חלוקה_אמת).

· כאשר יש ספק, דחו לפייתון.

· אם אתה עדיין לא בטוח, דחה ל- Clojure.

· אם אתה אפילו יותר לא בטוח, דחה את Common Lisp.

· זכור שאנחנו לא Clojure. אנחנו לא נפוצים ליספ. אנחנו פייתון הומויקוני, עם
סיביות נוספות שהגיוניות.

מערך & הֲזָחָה
· הימנע מרווחים נגררים. הם מבאסים!

· הזחה תהיה 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)
נ ;; כן, אני אוהב להקיש באקראי על מקש הרווח
(+ (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)))
)
) ; גאה, שרוף את זה באש

· יישור אנכי לתת בלוקים.

(תן [[foo (בר)]
[qux (baz)]]
(פו קווקס))

· הערות מוטבעות יהיו שני רווחים מסוף הקוד; תמיד חייב להיות להם א
רווח בין תו ההערה לתחילת ההערה. כמו כן, נסה לא
להעיר את המובן מאליו.

;; טוֹב
(setv ind (dec x)); אינדקס מתחיל מ-0

;; תואם לסגנון אבל רק מציין את המובן מאליו
(setv ind (dec x)); מגדיר את האינדקס ל-x-1

;; רַע
(setv ind (dec x)); הקלדת מילים בשביל הכיף

סִמוּל סִגְנוֹן
· כמוסכמה, השתדלו לא להשתמש def עבור כל דבר אחר מלבד משתנים גלובליים; להשתמש setv
בתוך פונקציות, לולאות וכו'.

;; טוב (ומועדף)
(בגדר *מגבלה* 400000)

(defn fibs [ab]
(בעוד שזה נכון
(תשואה א)
(setv (, ab) (, b (+ ab)))))

;; רע (ולא מועדף)
(defn fibs [ab]
(בעוד שזה נכון
(תשואה א)
(def (, ab) (, b (+ ab)))))

· אל תשתמש בתחביר s-expression כאשר התחביר הווקטורי מיועד. למשל, העובדה
שהראשונה מבין שתי הדוגמאות הללו עובדת היא רק בגלל שהמהדר לא מוגזם
קַפְּדָנִי. במציאות, התחביר הנכון במקומות כגון זה הוא האחרון.

;; רע (ורשע)
(defn foo (x) (הדפס x))
(פו 1)

;; טוב (ומועדף)
(defn foo [x] (הדפס x))
(פו 1)

· השתמש במאקרו השחלה או בפקודות המאקרו של זנב השחלה כאשר נתקלים בקיננות עמוקה
ביטויי s. עם זאת, היה נבון בעת ​​השימוש בהם. האם להשתמש בהם כאשר בהירות ו
הקריאות משתפרת; אל תבנה ביטויים מפותלים וקשים להבנה.

;; מועדף
(בגדר *שמות*
(עם [f (פתח "names.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ","") (ממוין))))

;; לא כל כך טוב
(בגדר *שמות*
(עם [f (פתח "names.txt")]
(ממוין (.split "," (.replace "\"" "" (.strip (.read f)))))))

;; כנראה לא רעיון טוב
(ריבוע הגנה? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· סימון נקודות בסגנון Clojure עדיף על פני הקריאה הישירה של שיטת האובייקט,
אם כי שניהם ימשיכו להיות נתמכים.

;; טוֹב
(עם [fd (פתוח"/ etc / passwd")]
(הדפס (.readlines fd)))

;; לא כל כך טוב
(עם [fd (פתוח"/ etc / passwd")]
(הדפס (fd.readlines)))

סיכום
"האופנה דועכת, הסגנון הוא נצחי" - איב סן לורן

מדריך זה הוא רק קבוצה של הנחיות קהילה, וברור שהנחיות קהילה כן
לא הגיוני בלי קהילה פעילה. תרומות יתקבלו בברכה. הצטרפו אלינו ל-#hy in
freenode, בלוג על זה, צייץ על זה, והכי חשוב, תהנה עם Hy.

תודה
· מדריך זה שואב השראה רבה מ @paultag הפוסט של הבלוג Hy הישרדות להדריך

· קלוז'ורה סִגְנוֹן להדריך

תיעוד מדד

תוכן:

פיקוד קו מִמְשָׁק
hy
פיקוד קו אפשרויות
-c
בצע את קוד Hy ב הפקודה.

$ hy -c "(הדפס (+ 2 2))"
4

-i
בצע את קוד Hy ב הפקודה, ואז הישאר ב-REPL.

-m
בצע את קוד Hy ב מודול, לרבות defmain אם מוגדר.

אל האני -m דגל מסיים את רשימת האפשרויות כך שכל הארגומנטים לאחר ה- מודול שם
מועברים למודול ב sys.argv.

חדש בגרסה 0.10.2.

--מרגל הדפס קוד Python מקביל לפני הביצוע. לדוגמה:

=> (defn salutationsnm [שם] (הדפס (+ "Hy " name "!")))
def salutationsnm(שם):
return print(((u'Hy ' + name) + u'!'))
=> (סלutationsnm "שמך")
salutationsnm(u'YourName')
היי השם שלך!
=>

חדש בגרסה 0.9.11.

--הצג-עקבות
הדפס עקבות מורחבות עבור יוצאי Hy.

חדש בגרסה 0.9.12.

-v הדפס את מספר הגרסה של Hy וצא.

hyc
פיקוד קו אפשרויות
קוֹבֶץ[, fileN]
הידור קוד Hy לקוד בייט של Python. לדוגמה, שמור את הקוד הבא בשם
hyname.hy:

(בהגדרת הי-הי [שם]
(הדפס (+ "היי " שם "!")))

(היי-היי "אפרומן")

ואז רוץ:

$ hyc hyname.hy
$ python hyname.pyc
היי אפרומן!

hy2py
חדש בגרסה 0.10.1.

פיקוד קו אפשרויות
-s

--עם-מקור
הצג את מבנה המקור המנתח.

-a

--עם-אסט
הצג את ה-AST שנוצר.

-נ.פ.

--ללא פיתון
אל תראה את קוד Python שנוצר מה-AST.

Hy ( שפה)
אזהרה:
זה לא שלם; אנא שקול לתרום למאמץ התיעוד.

תֵאוֹרִיָה of Hy
Hy שומרת על כל השאר תאימות של 100% לשני הכיוונים עם Python
עצמו. כל קוד Hy עוקב אחר כמה כללים פשוטים. שנן את זה, כפי שזה הולך להיכנס
שימושי.

כללים אלה עוזרים להבטיח שקוד Hy הוא אידיומטי וניתן לממשק בשתי השפות.

· סמלים במחממי אוזניים יתורגמו לגרסה בעלת האותיות הגבוהות של המחרוזת הזו. ל
דוגמא, Foo יהפוך FOO.

· ישויות UTF-8 יקודדו באמצעות punycode ובראשיתו הי_. לדוגמה, ⚘
יהפוך hy_w7h, ♥ יהפוך hy_g6h, ו אני♥ אתה יהפוך hy_iu_t0x.

· סמלים המכילים מקפים יוחלפו בקווים תחתונים. לדוגמה,
render-template יהפוך לדקלם. זה אומר שסמלים עם מקפים יהיו
להצל את המקבילות שלהם לקו התחתון, ולהיפך.

מובנה
Hy כולל מספר צורות מיוחדות המשמשות ליצירת Python AST נכונה.
להלן צורות "מיוחדות", שבהן עשויות להיות התנהגות מעט בלתי צפויה
כמה מצבים.

.
חדש בגרסה 0.10.0.

. משמש לביצוע גישה לתכונה על אובייקטים. הוא משתמש ב-DSL קטן כדי לאפשר מהיר
גישה לתכונות ופריטים במבנה נתונים מקונן.

לדוגמה,

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

קומפילציה עד:

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

. מרכיב את הטיעון הראשון שלו (בדוגמה, Foo) כאובייקט שעליו לעשות את
תכונה זלזול. הוא משתמש בסמלים חשופים כתכונות לגישה (בדוגמה, בָּר,
באז, קפף), ומרכיב את התוכן של רשימות (בדוגמה, [(+ 1 2)]) להצמדה לאינדקס.
ארגומנטים אחרים זורקים שגיאת קומפילציה.

גישה לתכונות לא ידועות זורקת א AttributeError. גישה למפתחות לא ידועים זורקת א
אינדקס שגיאה (על רשימות וטופלים) או א שגיאת מפתח (על מילונים).

->
-> (או ה השחלה מאקרו) משמש כדי למנוע קינון של ביטויים. מאקרו השרשור
מוסיף כל ביטוי למקום הארגומנט הראשון של הביטוי הבא. הבאים
הקוד מדגים זאת:

=> (defn output [ab] (הדפס ab))
=> (-> (+ 4 6) (פלט 5))
10 5

- >>
- >> (או ה השחלה זנב מאקרו) דומה ל- השחלה מאקרו, אבל במקום
הוספת כל ביטוי לארגומנט הראשון של הביטוי הבא, הוא מוסיף אותו בתור
טיעון אחרון. הקוד הבא מדגים זאת:

=> (defn output [ab] (הדפס ab))
=> (->> (+ 4 6) (פלט 5))
5 10

להגיש מועמדות
להגיש מועמדות משמש להחלת רשימה אופציונלית של ארגומנטים ומילון אופציונלי של kwargs
לפונקציה.

נוֹהָג: (להגיש מועמדות fn-name [טיעונים] [קווארגס])

דוגמאות:

(דעה ת'אנק []
"היי שם")

(להחיל thunk)
;=> "היי שם"

(בגדר רכישה כוללת [סכום מחיר ואופציונלי [עמלות 1.05] [מע"מ 1.1]]
(* מחיר סכום עמלות מע"מ))

(החל רכישה כוללת [10 15])
;=> 173.25

(החל רכישה כוללת [10 15] {"vat" 1.05})
;=> 165.375

(החל רכישה כוללת [] {"price" 10 "amount" 15 "vat" 1.05})
;=> 165.375

ו
ו משמש בביטויים לוגיים. זה דורש לפחות שני פרמטרים. אם כל הפרמטרים
להעריך ל נָכוֹן, הפרמטר האחרון מוחזר. בכל מקרה אחר, הערך השקרי הראשון
יוחזר. שימוש לדוגמה:

=> (ואמת לא נכון)
לא נכון

=> (ואמת נכון)
נָכוֹן

=> (ואמת 1)
1

=> (ואמת [] לא נכון נכון)
[]

הערה:
ו מקצר ומפסיק להעריך פרמטרים ברגע שהשקר הראשון מופיע
נתקל ב.

=> (ולא נכון (הדפס "שלום"))
לא נכון

לִטעוֹן
לִטעוֹן משמש לאימות תנאים בזמן שהתוכנית פועלת. אם התנאי לא
נפגש, א AssertionError מורם. לִטעוֹן עשוי לקחת פרמטר אחד או שניים. הראשון
פרמטר הוא התנאי שיש לבדוק, והוא צריך להעריך לאחד מהם נָכוֹן or לא נכון. ה
פרמטר שני, אופציונלי, הוא תווית עבור ה-assert, והוא המחרוזת שתהיה
גדל עם ה AssertionError. לדוגמה:

(טעון (= משתנה צפוי-ערך))

(טען שקר)
; AssertionError

(לטעון (= 1 2) "אחד צריך להיות שווה לשניים")
; AssertionError: אחד צריך להיות שווה לשניים

Assoc
Assoc משמש לשיוך מפתח לערך במילון או להגדרת אינדקס של רשימה
לערך. זה דורש לפחות שלושה פרמטרים: ה נתונים מִבְנֶה לשינוי, א מפתח
or מדדו ערך. אם נעשה שימוש ביותר משלושה פרמטרים, הוא יתחבר בזוגות.

דוגמאות לשימוש:

=>(תן [[אוסף {}]]
... (אוסף assoc "כלב" "נביחה")
... (אוסף הדפסים))
{u'Dog': u'Bark'}

=>(תן [[אוסף {}]]
... (אוסף assoc "כלב" "נביחה" "חתול" "מיאו")
... (אוסף הדפסים))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(תנו [[אוסף [1 2 3 4]]]
... (אסוס אוסף 2 אין)
... (אוסף הדפסים))
[1, 2, אין, 4]

הערה:
Assoc משנה את מבנה הנתונים במקום ומחזיר ללא חתימה.

לשבור
לשבור משמש כדי לפרוץ מתוך לולאה. זה מסיים את הלולאה באופן מיידי. הבאים
לדוגמא יש אינסוף בזמן לולאה שמסתיימת ברגע שהמשתמש נכנס k.

(בעוד נכון (אם (= "k" (קלט גולמי "? "))
(לשבור)
(הדפס "נסה שוב")))

תנאי
תנאי יכול לשמש לבניית מקוננים if הצהרות. הדוגמה הבאה מציגה את
הקשר בין המאקרו להתרחבותו:

(תנאי [תנאי-1 תוצאה-1]
[תנאי-2 תוצאה-2])

(אם מצב-1 תוצאה-1
(אם מצב-2 תוצאה-2))

כפי שמוצג להלן, רק בלוק התוצאה התואם הראשון מבוצע.

=> (הגדר ערך בדיקה [ערך]
... (cond [(< ערך 5) (הדפס "הערך קטן מ-5")]
... [(= ערך 5) (הדפס "ערך שווה ל-5")]
... [(> ערך 5) (הדפס "הערך גדול מ-5")]
... [נכון (הדפס "ערך הוא משהו שהוא לא צריך להיות")]))

=> (ערך המחאה 6)
הערך גדול מ-5

להמשיך
להמשיך מחזיר את הביצוע לתחילת לולאה. בדוגמה הבאה,
(תופעת לוואי1) נקרא לכל איטרציה. (תופעת לוואי2), לעומת זאת, נקרא רק
כל ערך אחר ברשימה.

;; בהנחה ש(תופעת לוואי1) ו(תופעת לוואי2) הם פונקציות ו
;; אוסף הוא רשימה של ערכים מספריים

(עבור [x collection]
(לַעֲשׂוֹת
(תופעת לוואי1 x)
(אם (% x 2)
(לְהַמשִׁיך))
(תופעת לוואי2 x)))

dict-comp
dict-comp משמש ליצירת מילונים. זה דורש שלושה או ארבעה פרמטרים. הראשון
שני פרמטרים מיועדים לשליטה על ערך ההחזרה (צמד מפתח-ערך) ואילו השלישי הוא
משמש לבחירת פריטים מרצף. ניתן להשתמש בפרמטר הרביעי והאופציונלי כדי
לסנן חלק מהפריטים ברצף על סמך ביטוי מותנה.

=> (dict-comp x (* x 2) [x (טווח 10)] (מוזר? x))
{1: 2, 3: 6, 9: 18, 5: 10, 7: 14}

do / progn
do ו progn משמשים להערכת כל אחד מהטיעונים שלהם ולהחזיר את האחרון. לַחֲזוֹר
ערכים מכל ארגומנט אחר מלבד הארגומנט האחרון נמחקים. ניתן להשתמש בו ב למבדה or
list-comp כדי לבצע לוגיקה מורכבת יותר כפי שמוצג באחת מהדוגמאות הבאות.

קצת שימוש לדוגמה:

=> (אם זה נכון
... (עשה (הדפיס "תופעות לוואי נדנדות!")
... (הדפס "כן, באמת!")))
תופעות הלוואי רוק!
כן באמת!

;; בהנחה ש(תופעת לוואי) היא פונקציה שאנו רוצים לקרוא לכל אחת מהן
;; וכל ערך ברשימה, אבל שערך ההחזר שלו לא אכפת לנו
=> (list-comp (לעשות (תופעת לוואי x)
... (אם (< x 5) (* 2 x)
... (* 4 x)))
... (x (טווח 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do יכול לקבל כל מספר של ארגומנטים, מ-1 עד n.

def / setv
def ו setv משמשים לקשירת ערך, אובייקט או פונקציה לסמל. לדוגמה:

=> (שמות בגדר ["אליס" "בוב" "צ'רלי")])
=> (שמות להדפיס)
[u'Alice', u'Bob', u'Charlie']

=> (מונה טלוויזיה (fn [פריט אוסף] (פריט אוסף .count)))
=> (מונה [1 2 3 4 5 2 3] 2)
2

defclass
כיתות חדשות מוכרזות עם defclass. זה יכול לקחת שני פרמטרים אופציונליים: וקטור
הגדרת מחלקות-על אפשריות ווקטור נוסף המכיל תכונות של החדש
מחלקה כשני וקטורים של פריט.

(שם defclass class [super-class-1 super-class-2]
[[ערך תכונה]])

ניתן לאגד שני ערכים ופונקציות במחלקה החדשה כפי שמוצג בדוגמה שלהלן:

=> (דיפלוקס חתול []
... [[גיל ללא]
... [צבע "לבן"]
... [דבר (fn [עצמי] (הדפס "מיאו")]])

=> (נקודה בהחלט (חתול))
=> (setv spot.colour "שחור")
'שָׁחוֹר'
=> (נקודה .speak)
מיאו

defn / defun
defn ו defun פקודות מאקרו משמשות להגדרת פונקציות. הם לוקחים שלושה פרמטרים: ה שם
של הפונקציה להגדיר, וקטור של פרמטרים, וה גוּף של הפונקציה:

(שם הגדרה [params] body)

פרמטרים עשויים לכלול את מילות המפתח הבאות לפניהם:

&אופציונאלי
פרמטר הוא אופציונלי. הפרמטר יכול להינתן כרשימה של שני פריטים, כאשר ה-
האלמנט הראשון הוא שם הפרמטר והשני הוא ערך ברירת המחדל. הפרמטר
ניתן לתת גם כפריט בודד, ובמקרה זה ערך ברירת המחדל הוא ללא חתימה.

=> (הגדר ערך כולל [ערך &אופציונלי [מס ערך מוסף 10]]
... (+ (/ (* ערך ערך מוסף-מס) 100) ערך))

=> (ערך כולל 100)
110.0

=> (ערך כולל 100 1)
101.0

&מַפְתֵחַ

&kwargs
הפרמטר יכיל 0 או יותר ארגומנטים של מילת מפתח.

דוגמאות הקוד הבאות מגדירות פונקציה שתדפיס את כל מילות המפתח
טיעונים וערכיהם.

=> (פרמטרי הדפסה של defn [&kwargs kwargs]
... (עבור [(, kv) (.items kwargs)] (הדפס kv)))

=> (החל פרמטרי הדפסה [] {"parameter-1" 1 "parameter-2" 2})
פרמטר-2 2
פרמטר-1 1

&מנוחה הפרמטר יכיל 0 ארגומנטים מיקוםיים או יותר. שום עמדה אחרת
אפשר לציין ארגומנטים אחרי זה.

דוגמא הקוד הבאה מגדירה פונקציה שניתן לתת 0 עד n מספרית
פרמטרים. לאחר מכן הוא מסכם כל מספר אי זוגי ומחסיר כל מספר זוגי.

=> (הגדר זיג-זג-sum [&שאר מספרים]
(תן [[מספרים אי-זוגיים (רשימת-קומפם x [x מספרים] (אי-זוגי? x))]
[מספרים זוגיים (קומפ רשימה x [x מספרים] (זוגות? x))]]
(- (מספרים אי-זוגיים סכום) (סכום זוגיים))))

=> (זיג-זג-sum)
0
=> (זיג-זג-סכום 3 9 4)
8
=> (זיג-זג-סכום 1 2 3 4 5 6)
-3

defn-alias / defun-כינוי
חדש בגרסה 0.10.0.

אל האני defn-alias ו defun-כינוי פקודות מאקרו דומות מאוד defn, בהבחנה ש
במקום להגדיר פונקציה עם שם יחיד, אלה יכולים גם להגדיר כינויים. אַחֵר
מאשר לקחת רשימה של סמלים עבור שמות פונקציות כפרמטר הראשון, defn-alias ו
defun-כינוי אינם שונים מ defn ו defun.

=> (defn-כינוי [כינוי שם ראשי] []
... (הדפס "שלום!"))
=> (שם ראשי)
"שלום!"
=> (כינוי)
"שלום!"

defmain
חדש בגרסה 0.10.1.

אל האני defmain מאקרו מגדיר פונקציה ראשית שנקראת מיד עם sys.argv as
ארגומנטים אם ורק אם קובץ זה מבוצע כסקריפט. במילים אחרות, זה:

(defmain [&rest args]
(עשה-משהו-עם args))

שווה ערך ל:

def main(*args):
לעשות_משהו_עם(ארגס)
חזור 0

if __name__ == "__main__":
ייבוא
retval = main(*sys.arg)

if isinstance(retval, int):
sys.exit(retval)

שימו לב שכפי שאתם יכולים לראות למעלה, אם תחזירו מספר שלם מפונקציה זו, זה יהיה
משמש כסטטוס היציאה של הסקריפט שלך. (Python כברירת מחדל למצב יציאה 0 אחרת,
מה שאומר שהכל בסדר!)

(מאז (sys.exit 0) לא מופעלת במפורש במקרה של החזר ללא מספר שלם מ
defmain, כדאי לשים (defmain) בתור פיסת הקוד האחרונה בקובץ שלך.)

defmacro
defmacro משמש להגדרת פקודות מאקרו. הפורמט הכללי הוא (defmacro שם [פרמטרים]
expr).

הדוגמה הבאה מגדירה מאקרו שניתן להשתמש בו כדי להחליף סדר של אלמנטים בקוד,
המאפשר למשתמש לכתוב קוד בסימון אינפיקס, כאשר האופרטור נמצא בין ה-
אופרנדים.

=> (תיקון defmacro [קוד]
... (מעין ציטוט (
... (ללא ציטוט (קבל קוד 1))
... (ללא ציטוט (קבל קוד 0))
... (ללא ציטוט (קבל קוד 2)))))

=> (תיקון (1 + 1))
2

defmacro-alias
defmacro-alias משמש להגדרת פקודות מאקרו עם מספר שמות (כינויים). הפורמט הכללי
is (defmacro-alias [שמות] [פרמטרים] expr). זה יוצר מספר פקודות מאקרו עם אותו הדבר
רשימת פרמטרים וגוף, מתחת לרשימת השמות שצוינה.

הדוגמה הבאה מגדירה שתי פקודות מאקרו, שתיהן מאפשרות למשתמש לכתוב קוד
סימון אינפיקס.

=> (defmacro-alias [infix infi] [קוד]
... (מעין ציטוט (
... (ללא ציטוט (קבל קוד 1))
... (ללא ציטוט (קבל קוד 0))
... (ללא ציטוט (קבל קוד 2)))))

=> (תיקון (1 + 1))
2
=> (infi (1 + 1))
2

defmacro/g!
חדש בגרסה 0.9.12.

defmacro/g! הוא גרסה מיוחדת של defmacro שמשמש ליצירה אוטומטית gensym
עבור כל סמל שמתחיל ב g!.

לדוגמה, ג!א יהפוך (gensym "א").

לִרְאוֹת גַם:
קטע באמצעות-gensym

משחרר
חדש בגרסה 0.9.12.

משחרר מגדיר מאקרו קורא, המאפשר לך לבנות מחדש או לשנות תחביר.

=> (מפחזת ^ [expr] (הדפס expr))
=> #^(1 2 3 4)
(1)
=> #^"שלום"
"שלום"

לִרְאוֹת גַם:
מאקרו של קורא מדור

דל
חדש בגרסה 0.9.12.

דל מסיר אובייקט ממרחב השמות הנוכחי.

=> (setv foo 42)
=> (דל פו)
=> פו
Traceback (השיחה האחרונה אחרונה):
קובץ" ", שורה 1, ב
NameError: השם 'foo' אינו מוגדר

דל יכול גם להסיר אובייקטים ממיפויים, רשימות ועוד.

=> (בדיקת setv (רשימה (טווח 10)))
=> מבחן
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (מבחן פרוסה 2 4)) ;; הסר פריטים מ-2 עד 4 שאינם נכללים
=> מבחן
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "בר"})
=> dic
{"פו בר"}
=> (דל (קבל dic "foo"))
=> dic
{}

דוטו
חדש בגרסה 0.10.1.

דוטו משמש כדי לפשט רצף של קריאות מתודה לאובייקט.

=> (doto [] (.append 1) (.append 2) .reverse)
[2 1]

=> (אוסף טלוויזיה [])
=> (.append collection 1)
=> (.append collection 2)
=> (אוסף הפוך)
=> אוסף
[2 1]

הערכה
הערכה מעריך ביטוי במירכאות ומחזיר את הערך.

=> (eval '(הדפס "Hello World"))
"שלום עולם"

eval-and-compile
eval-when-compile
ראשון / מכונית
ראשון ו מכונית הם פקודות מאקרו לגישה לרכיב הראשון של אוסף:

=> (ראשון (טווח 10))
0

ל
ל משמש לקריאה לפונקציה עבור כל אלמנט ברשימה או וקטור. התוצאות של כל אחד
השיחה נמחקת וה ל הביטוי חוזר ללא חתימה במקום זאת. הקוד לדוגמה חוזר על עצמו
יותר אוסף ולכל אחד אלמנט in אוסף קורא ל- תופעות לוואי לתפקד עם
אלמנט כטענה שלו:

;; בהנחה ש(תופעת לוואי) היא פונקציה שלוקחת פרמטר בודד
(עבור [אוסף אלמנטים] (אלמנט תופעת לוואי))

;; עבור יכול להיות בלוק אחר אופציונלי
(עבור [אוסף אלמנטים] (אלמנט תופעת לוואי)
(אחר (תופעת לוואי-2)))

האופציונלי אחר בלוק מבוצע רק אם ה- ל לולאה מסתיימת כרגיל. אם ה
הוצאה להורג נעצרת עם לשבור, ה אחר בלוק לא מבוצע.

=> (עבור [אלמנט [1 2 3]] (אם (< אלמנט 3)
... (אלמנט הדפסה)
... (לשבור))
... (אחר (הדפס "לולאה נגמרה")))
1
2

=> (עבור [אלמנט [1 2 3]] (אם (< אלמנט 4)
... (אלמנט הדפסה)
... (לשבור))
... (אחר (הדפס "לולאה נגמרה")))
1
2
3
הלולאה הסתיימה

genexpr
genexpr משמש ליצירת ביטויי מחולל. זה דורש שניים או שלושה פרמטרים. ה
הפרמטר הראשון הוא הביטוי השולט בערך ההחזר, בעוד שהשני משמש
כדי לבחור פריטים מרשימה. ניתן להשתמש בפרמטר השלישי והאופציונלי לסינון
חלק מהפריטים ברשימה מבוססים על ביטוי מותנה. genexpr דומה ל
list-comp, אלא שהוא מחזיר איטרבל שמעריך ערכים אחד אחד במקום
להעריך אותם באופן מיידי.

=> (אוסף בגדר (טווח 10))
=> (מסונן בהחלט (genexpr x [x collection] (אפילו? x)))
=> (רשימה מסוננת)
[0, 2, 4, 6, 8]

gensym
חדש בגרסה 0.9.12.

gensym משמש ליצירת סמל ייחודי המאפשר לכתוב פקודות מאקרו ללא
התנגשות שם משתנה בשוגג.

=> (gensym)
u':G_1235'

=> (gensym "x")
u':x_1236'

לִרְאוֹת גַם:
קטע באמצעות-gensym

לקבל
לקבל משמש לגישה לאלמנטים בודדים ברשימות ובמילונים. לקבל לוקח שני פרמטרים:
מה היא נתונים מִבְנֶה ו מדד or מפתח של הפריט. לאחר מכן הוא יחזיר את המתאים
ערך מהמילון או מהרשימה. שימוש לדוגמה:

=> (תנו ל[[בעלי חיים {"כלב" "לנבוח" "חתול" "מיאו"}]
... [מספרים ["אפס" "אחד" "שתיים" "שלוש"]]]
... (הדפס (קבל חיות "כלב"))
... (הדפס (קבל מספרים 2)))
לנבוח
שתיים

הערה:
לקבל מעלה KeyError אם נשאל מילון עבור מפתח לא קיים.

הערה:
לקבל מעלה IndexError אם נשאלת שאילתה של רשימה או tuple עבור אינדקס שיצא ממנו
גבולות.

גלוֹבָּלִי
גלוֹבָּלִי ניתן להשתמש כדי לסמן סמל כגלובל. זה מאפשר למתכנת להקצות א
ערך לסמל גלובלי. קריאת סמל גלובלי אינה מחייבת את גלוֹבָּלִי מילת מפתח --
רק להקצות את זה.

הדוגמה הבאה מראה כיצד הסמל הגלובלי a מוקצה ערך בפונקציה ו
מודפס מאוחר יותר בפונקציה אחרת. בלי ה גלוֹבָּלִי מילת מפתח, הפונקציה השנייה
היה זורק א שם שגיאה.

(הגדר ערך [ערך]
(א גלובלי)
(setv a value))

(defn print-a []
(הדפס א))

(סט-a 5)
(הדפס-א)

if / אם לא
חדש בגרסה 0.10.0: אם-לא

if משמש לבחירה מותנית בקוד לביצוע. זה חייב להכיל תנאי
בלוק והחסימה שיבוצעו אם בלוק התנאי מעריך נָכוֹן. לבחירה,
הוא עשוי להכיל בלוק אחרון שמתבצע במקרה שההערכה של התנאי היא
לא נכון.

אם לא דומה, אך הבלוק השני יתבצע כאשר התנאי נכשל תוך כדי
הבלוק השלישי והאחרון מבוצע כאשר הבדיקה מצליחה -- סדר הפוך מ if.

שימוש לדוגמא:

(אם (כסף נשאר? חשבון)
(הדפס "בוא נלך לקניות")
(הדפס "בוא נלך לעבוד"))

(אם לא (נשאר כסף? חשבון)
(הדפס "בוא נלך לעבוד")
(הדפס "בוא נלך לקניות"))

אמיתות פייתון מכבדת. ללא חתימה, לא נכון, אפס מכל סוג מספרי, רצף ריק,
ומילון ריק נחשבים לא נכון; כל השאר נחשב נָכוֹן.

lisp-if / חיים ו ליפס-אם-לא / הרים-לא
חדש בגרסה 0.10.0.

חדש בגרסה 0.10.2: lisp-if-not / lif-not

לאלו שמעדיפים יותר ליספי if סעיף, יש לנו lisp-if, או חיים. זֶה רק רואה
ללא חתימה / אפס להיות שקר! כל שאר ערכי ה-Python "שקריים" נחשבים לאמיתיים.
לעומת זאת, יש לנו ליפס-אם-לא ו הרים-לא במקביל ל if ו אם לא שמתהפך
ההשוואה.

=> (lisp-אם נכון "true" "false")
"נָכוֹן"
=> (lisp-if False "true" "false")
"נָכוֹן"
=> (lisp-if 0 "true" "false")
"נָכוֹן"
=> (lisp-אם אפס "true" "false")
"שֶׁקֶר"
=> (lisp-if None "true" "false")
"שֶׁקֶר"
=> (ליsp-if-not nil "true" "false")
"נָכוֹן"
=> (lisp-if-not None "true" "false")
"נָכוֹן"
=> (lisp-if-not False "true" "false")
"שֶׁקֶר"

; שווה אבל קצר יותר
=> (חיים נכון "נכון" "שקר")
"נָכוֹן"
=> (ללא "נכון" "שקר")
"שֶׁקֶר"
=> (חי-לא None "true" "false")
"נָכוֹן"

לייבא
לייבא משמש לייבוא ​​מודולים, כמו ב-Python. ישנן מספר דרכים לכך לייבא יכול
לשמש.

;; מייבא כל אחד מהמודולים הללו
;;
;; פִּיתוֹן:
;; ייבוא ​​מערכת
;; ייבוא ​​OS.path
(ייבוא ​​sys os.path)

;; ייבוא ​​ממודול
;;
;; Python: מ-os.path ייבוא ​​קיים, isdir, isfile
(ייבוא ​​[os.path [קיים קובץ isdir isfile]])

;; ייבוא ​​עם כינוי
;;
;; Python: יבא את sys כ-systest
(יבא [sys :as systest])

;; אתה יכול לרשום כמה יבואים שאתה רוצה מסוגים שונים.
(ייבוא ​​[tests.resources [kwtest function-with-a-dash]]
[os.path [קיים isdir isfile]]
[sys :as systest])

;; ייבא את כל פונקציות המודול למרחב השמות הנוכחי
(ייבוא ​​[sys [*]])

למבדה / fn
למבדה ו fn ניתן להשתמש כדי להגדיר פונקציה אנונימית. הפרמטרים דומים ל
defn: הפרמטר הראשון הוא וקטור של פרמטרים והשאר הוא גוף ה-
פונקציה. למבדה מחזירה פונקציה חדשה. בדוגמה הבאה, פונקציה אנונימית
מוגדר ומועבר לפונקציה אחרת לסינון פלט.

=> (בגדר אנשים [{:name "Alice" :age 20}
... {:שם "בוב" :גיל 25}
... {:שם "צ'רלי" :גיל 50}
... {:שם "דייב" :גיל 5}])

=> (הגדר אנשים לתצוגה [מסנן אנשים]
... (עבור [אדם אנשים] (אם (אדם מסנן) (הדפס (:שם אדם)))))

=> (אנשים לתצוגה (fn [person] (< (: age person) 25)))
אליס
דייב

בדיוק כמו בהגדרות פונקציות רגילות, אם האלמנט הראשון של הגוף הוא מיתר, הוא
משמש כמחרוזת. זה שימושי עבור מתן docstrings לשיטות מחלקות.

=> (שידור פעמים-שלוש
... (fn [x]
... "מכפיל את הקלט בשלוש ומחזיר את התוצאה."
... (* x 3)))

ניתן לאשר זאת באמצעות המובנה של Python לעזור פוּנקצִיָה:

=> (עזרה פעמים-שלוש)
עזרה בנושא זמני_שלוש:

פעמים_שלוש (x)
מכפיל את הקלט בשלוש ומחזיר את התוצאה
(סוֹף)

אחרון
חדש בגרסה 0.10.2.

אחרון יכול לשמש לגישה לרכיב האחרון של אוסף:

=> (אחרון [2 4 6])
6

לתת
לתת משמש ליצירת משתנים בהיקף מילוני. הם נוצרים בתחילת ה
לתת נוצרים ומפסיקים להתקיים לאחר הטופס. הדוגמה הבאה מציגה זאת
התנהגות:

=> (תן [[x 5]] (הדפס x)
... (תן [[x 6]] (הדפס x))
... (הדפס x))
5
6
5

אל האני לתת מאקרו לוקח שני פרמטרים: הגדרת וקטור משתנים ו גוּף אשר מקבל
יצא לפועל. משתנים הוא וקטור שבו כל אלמנט הוא משתנה בודד או וקטור
הגדרת זוג ערכים משתנים. במקרה של משתנה בודד, מוקצה לו ערך
ללא חתימה; אחרת, נעשה שימוש בערך המסופק.

=> (תן [x [y 5]] (הדפס xy))
אין 5

list-comp
list-comp מבצע הבנת רשימות. זה דורש שניים או שלושה פרמטרים. הראשון
פרמטר הוא הביטוי השולט בערך ההחזר, בעוד שהשני רגיל
בחר פריטים מרשימה. ניתן להשתמש בפרמטר השלישי והאופציונלי כדי לסנן חלק
של הפריטים ברשימה על סמך ביטוי מותנה. כמה דוגמאות:

=> (אוסף בגדר (טווח 10))
=> (קומפ רשימת x [x collection])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (רשימות-קומפ (* x 2) [x אוסף])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

=> (רשימות-קומפ (* x 2) [x collection] (< x 5))
[0, 2, 4, 6, 8]

לֹא
לֹא משמש בביטויים לוגיים. זה לוקח פרמטר בודד ומחזיר הפוך
ערך אמת. אם נָכוֹן ניתן כפרמטר, לא נכון יוחזר, ולהיפך.
שימוש לדוגמא:

=> (לא נכון)
לא נכון

=> (לא שקר)
נָכוֹן

=> (לא אין)
נָכוֹן

or
or משמש בביטויים לוגיים. זה דורש לפחות שני פרמטרים. זה יחזיר את
הפרמטר הראשון שאינו שקרי. אם לא קיים ערך כזה, הפרמטר האחרון יוחזר.

=> (או True False)
נָכוֹן

=> (ושקר שקר)
לא נכון

=> (ולא נכון 1 נכון לא נכון)
1

הערה:
or מקצר ומפסיק להעריך פרמטרים ברגע שהערך האמיתי הראשון הוא
נתקל ב.

=> (או נכון (הדפס "שלום"))
נָכוֹן

הדפסה
הדפסה משמש לפלט על המסך. שימוש לדוגמה:

(הדפס "שלום עולם!")

הערה:
הדפסה תמיד חוזר ללא חתימה.

כמו ציטוט
כמו ציטוט מאפשר לך לצטט טופס, אבל גם להעריך באופן סלקטיבי ביטויים.
ביטויים בתוך א כמו ציטוט ניתן להעריך באופן סלקטיבי באמצעות עַד כָּאן (~).
ניתן לחבר צורה מוערכת גם באמצעות unquote-splice (~@). כמו ציטוט יכול להיות גם
נכתב באמצעות הציטוט האחורי (`) סמל.

;; תן 'qux' להיות משתנה עם ערך (bar baz)
`(foo ~qux)
; שווה ערך ל-'(foo (bar baz))
`(פו ~@qux)
; שווה ערך ל'(פו בר באז)

לצטט
לצטט מחזירה את הטופס שהועבר אליו מבלי להעריך אותו. לצטט יכול להיות לחילופין
נכתב באמצעות האפוסתרוף (') סמל.

=> (setv x '(הדפס "Hello World"))
; המשתנה x מוגדר לביטוי ולא מוערך
=> x
(u'print' u'Hello World')
=> (הערך x)
שלום עולם

לדרוש
לדרוש משמש לייבא פקודות מאקרו ממודול נתון. זה דורש לפחות פרמטר אחד
ציון המודול אילו פקודות מאקרו יש לייבא. ניתן לייבא מספר מודולים
עם סינגל לדרוש.

הדוגמה הבאה תייבא פקודות מאקרו מ מודול מספר 1 ו מודול מספר 2:

(דרוש מודול-1 מודול-2)

שאר / cdr
שאר ו cdr החזר את האוסף שעבר כארגומנט ללא האלמנט הראשון:

=> (מנוחה (טווח 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

set-comp
set-comp משמש ליצירת סטים. זה דורש שניים או שלושה פרמטרים. הפרמטר הראשון הוא
לשליטה בערך ההחזרה, בעוד השני משמש לבחירת פריטים מתוך א
סדר פעולות. ניתן להשתמש בפרמטר השלישי והאופציונלי כדי לסנן חלק מהפריטים פנימה
הרצף המבוסס על ביטוי מותנה.

=> (נתוני רשת [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x data] (מוזר? x))
{1, 3, 5}

פרוסה
פרוסה ניתן להשתמש כדי לקחת תת-קבוצה של רשימה וליצור ממנה רשימה חדשה. הצורה
לוקח לפחות פרמטר אחד המציין את הרשימה לחתוך. שני פרמטרים אופציונליים יכולים להיות
משמש כדי לתת את מיקום ההתחלה והסיום של קבוצת המשנה. אם הם לא מסופקים, ה
ערך ברירת המחדל של ללא חתימה ישמש במקום. הפרמטר האופציונלי השלישי משמש ל
שלב בקרה בין האלמנטים.

פרוסה עוקב אחר אותם כללים כמו מקבילו ב-Python. מדדים שליליים נספרים
החל מסוף הרשימה. קצת שימוש לדוגמה:

=> (אוסף בגדר (טווח 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)
[2, 4, 6]

=> (אוסף פרוסות -4 -2)
[6, 7]

לזרוק / להעלות
אל האני לזרוק or להעלות ניתן להשתמש בטפסים כדי להעלות א חריגה בזמן ריצה. שימוש לדוגמה:

(לזרוק)
; לשדרג מחדש את החריג האחרון

(זרוק IOError)
; זרוק IOError

(לזרוק (IOError "foobar"))
; זרוק IOEerror ("foobar")

לזרוק יכול לקבל טיעון יחיד (an חריגה class או מופע) או ללא ארגומנטים
להעלות מחדש את האחרון חריגה.

לנסות
אל האני לנסות טופס משמש כדי להתחיל א לנסות / לתפוס לַחסוֹם. הטופס משמש באופן הבא:

(לְנַסוֹת
(תפקוד מועד לשגיאות)
(תפוס [e ZeroDivisionError] (הדפס "חלוקה באפס"))
(אחר (הדפס "ללא שגיאות"))
(לבסוף (הדפס "הכל נעשה")))

לנסות חייב להכיל לפחות אחד לתפוס בלוק, ועשוי לכלול אופציונלי אחר or לבסוף
לַחסוֹם. אם הועלתה שגיאה עם בלוק תואם תואם במהלך הביצוע של
פונקציה מועדת לשגיאות, זה לתפוס חסימה תתבצע. אם לא מועלות שגיאות, ה אחר
בלוק מבוצע. ה לבסוף בלוק יבוצע אחרון ללא קשר לשאלה אם או לא
הועלתה שגיאה.

אלא אם כן
אל האני אלא אם כן מאקרו הוא קיצור לכתיבת an if הצהרה שבודקת אם הנתון
מותנה הוא לא נכון. להלן מוצג הרחבה של מאקרו זה.

(אלא אם כן הצהרה מותנית)

(אם מותנה
ללא חתימה
(עשה הצהרה))

עַד כָּאן
בתוך צורה כמו ציטוט, עַד כָּאן כופה הערכה של סמל. עַד כָּאן מכונה
הטילדה (~) סמל.

(שם בגדר "חיבוקים")
(כמו ציטוט (= שם (שם ללא מרכאות)))
;=> (u'=' u'name' u'Cuddles')

`(= שם ~שם)
;=> (u'=' u'name' u'Cuddles')

unquote-splice
unquote-splice מאלץ את ההערכה של סמל בתוך צורה כמו ציטוט, בדומה
עַד כָּאן. unquote-splice ניתן להשתמש רק כאשר הסמל שאינו מצוטט מכיל
ערך חוזר, כיוון שהוא "מחבר" ​​את אותו ניתן לחזור לצורת המירכאות. unquote-splice is
כינוי ל- ~@ סמל.

(מספרים מוגדרים [1 2 3 4])
(כמו ציטוט (+ (ללא ציטוט-חבור מספרים)))
;=> (u'+' 1L 2L 3L 4L)

`(+ ~@nums)
;=> (u'+' 1L 2L 3L 4L)

מתי
מתי דומה ל אלא אם כן, אלא שהוא בודק כאשר התנאי הנתון הוא נָכוֹן. זה לא
אפשרי לקבל אחר לחסום ב-a מתי מאקרו. להלן מראה את הרחבה של
מאקרו.

(כאשר הצהרה מותנית)

(אם מותנה (עשה הצהרה))

בזמן
בזמן משמש לביצוע בלוק אחד או יותר כל עוד מתקיים תנאי. הבאים
הדוגמה תוציא "Hello world!" למסך ללא הגבלת זמן:

(בעוד נכון (הדפס "שלום עולם!"))

עם
עם משמש לעטוף ביצוע של בלוק בתוך מנהל הקשר. ההקשר
לאחר מכן המנהל יכול להגדיר את המערכת המקומית ולהפיל אותה בצורה מבוקרת. ה
דוגמה ארכיטיפית לשימוש עם הוא בעת עיבוד קבצים. עם יכול לקשור הקשר ל-an
טיעון או התעלם ממנו לחלוטין, כפי שמוצג להלן:

(עם בלוק [[arg (expr)]])

(עם בלוק [[(expr)]]

(עם בלוק [[arg (expr)] [(expr)]]

הדוגמה הבאה תפתח את ה חדשות קובץ והדפיס את תוכנו למסך. ה
הקובץ נסגר אוטומטית לאחר עיבודו.

(עם [[f (פתח "NEWS")]] (הדפס (.read f)))

עם דקורטור
עם דקורטור משמש לעטוף פונקציה עם אחרת. הפונקציה המבצעת את
עיטור צריך לקבל ערך יחיד: הפונקציה המקושטת, ולהחזיר ערך חדש
פונקציה. עם דקורטור לוקח לפחות שני פרמטרים: הפונקציה שמבצעת
עיטור והפונקציה המקושטת. יותר מפונקציית דקורטור אחת יכולה להיות
מיושם; הם יחולו לפי הסדר מהחיצוני אל הפנימי ביותר, כלומר. הראשון
הדקורטור יהיה החיצוני ביותר, וכן הלאה. מעצבים עם טיעונים נקראים צודקים
כמו שיחת פונקציה.

(עם-קישוט מעצב-כיף
(הגדיר פונקציה כלשהי [] ...)

(עם דקורטור דקורטור1 דקורטור2 ...
(הגדיר פונקציה כלשהי [] ...)

(עם דקורטור (דקורטור arg) ..
(הגדיר פונקציה כלשהי [] ...)

בדוגמה הבאה, Inc-Decorator משמש לקישוט הפונקציה תוספת עם
פונקציה שלוקחת שני פרמטרים וקוראת לפונקציה המעוטרת עם ערכים שהם
גדל ב-1. כאשר המעוטר תוספת נקרא עם ערכים 1 ו-1, הסוף
התוצאה תהיה 4 (1 + 1 + 1 + 1).

=> (defn inc-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 1) (+ value-2 1))))
=> (defn inc2-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 2) (+ value-2 2))))

=> (עם-Decorator Inc-Decorator (תוספת הגדרה [a b] (+ a b)))
=> (תוספת 1 1)
4
=> (עם-Decorator inc2-Decorator inc-Decorator
... (הגדיר תוספת [a b] (+ a b)))
=> (תוספת 1 1)
8

עם-gensyms
חדש בגרסה 0.9.12.

with-gensym משמש ליצירת קבוצה של gensym לשימוש במאקרו. הקוד הבא:

(עם-gensyms [a b c]
...)

מתרחב ל:

(תן [[a (gensym)
[b (gensym)
[c (gensym)]]
...)

לִרְאוֹת גַם:
קטע באמצעות-gensym

תשואה
תשואה משמש ליצירת אובייקט מחולל המחזיר ערך אחד או יותר. הגנרטור
ניתן לחזרה ולפיכך ניתן להשתמש בו בלולאות, הבנת רשימות ודומים אחרים
בונה.

הפונקציה מספרים אקראיים מראה כיצד ניתן להשתמש בגנרטורים ליצירת סדרות אינסופיות
מבלי לצרוך כמות אינסופית של זיכרון.

=> (הגדר כפל [מקדמי בסיסים]
... (עבור [[(, מקדם בסיס) (מקדמי בסיסים zip)]]
... (תשואה (* מקדם בסיס))))

=> (כפל (טווח 5) (טווח 5))


=> (ערך רשימה-קומפ [ערך (הכפל (טווח 10) (טווח 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (ייבוא ​​אקראי)
=> (הגדר מספרים אקראיים [נמוך גבוה]
... (בעוד True (תשואה (.randint אקראי נמוך גבוה))))
=> (רשימת-קומפ 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 ליבה
ליבה פונקציות
אבל האחרון
נוֹהָג: (butlast אוסף)

מחזירה איטרטור של הכל מלבד הפריט האחרון ב קול.

=> (רשימה (butlast (טווח 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (רשימה (butlast [1]))
[]

=> (רשימה (butlast []))
[]

=> (יבא את הכלים)
=> (רשימה (קח 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

קול?
חדש בגרסה 0.10.0.

נוֹהָג: (קול? x)

החזרים נָכוֹן if x ניתן לחזרה ולא מחרוזת.

=> (אוסף? [1 2 3 4])
נָכוֹן

=> (אוסף? {"a" 1 "b" 2})
נָכוֹן

=> (אוסף? "abc")
לא נכון

חסרונות
חדש בגרסה 0.10.0.

נוֹהָג: (חסרונות a b)

מחזיר תא חסרונות טרי עם מכונית a ו-cdr b.

=> (setv a (חסרונות 'hd 'tl))

=> (= 'hd (מכונית a))
נָכוֹן

=> (= 'tl (cdr a))
נָכוֹן

אידיוטים?
חדש בגרסה 0.10.0.

נוֹהָג: (חסרונות? פו)

בודק אם Foo הוא תא חסרונות.

=> (setv a (חסרונות 'hd 'tl))

=> (חסרונות? א)
נָכוֹן

=> (החסרונות? אפסי)
לא נכון

=> (חסרונות? [1 2 3])
לא נכון

דצמבר
נוֹהָג: (בדצמבר x)

מחזיר אחד פחות מ x. שווה ערך ל (- x 1). מעלה טעות הקלדה if (לא (מספרית? איקס)).

=> (3 בדצמבר)
2

=> (0 בדצמבר)
-1

=> (12.3 בדצמבר)
11.3

לפרק
חדש בגרסה 0.10.0.

נוֹהָג: (לְפַרֵק עץ &אופציונאלי [קודגן שֶׁקֶר])

זרוק את Python AST עבור Hy נתון עץ לפלט סטנדרטי. אם קודגן is נָכוֹן, הפונקציה
מדפיס קוד Python במקום זאת.

=> (פרק '(הדפס "Hello World!"))
מודול(
גוף=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], keywords=[], starargs=None, kwargs=None))])

=> (פרק '(הדפס "Hello World!") נכון)
print('שלום עולם!')

ריק?
נוֹהָג: (ריק? אוסף)

החזרים נָכוֹן if קול זה ריק. שווה ערך ל (= 0 (לן coll)).

=> (ריק? [])
נָכוֹן

=> (ריק? "")
נָכוֹן

=> (ריק? (, 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 (לא (מספרית? איקס)).

=> (אפילו? 2)
נָכוֹן

=> (אפילו? 13)
לא נכון

=> (אפילו? 0)
נָכוֹן

זהות
נוֹהָג: (זהות x)

מחזירה את הארגומנט שסופק לפונקציה.

=> (זהות 4)
4

=> (רשימה (זהות המפה [1 2 3 4]))
[1 2 3 4]

inc
נוֹהָג: (inc x)

מחזיר אחד יותר מ x. שווה ערך ל (+ x 1). מעלה טעות הקלדה if (לא (מספרית? איקס)).

=> (כולל 3)
4

=> (כולל 0)
1

=> (כולל 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 הוא מספר שלם. עבור Python 2, זה גם כן int or ארוך. עבור Python 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, 'א', 1, 'ב', 2, 'ג']

להתערב
חדש בגרסה 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])
נָכוֹן

=> ;; עובד עבור tuples
=> (ניתן לחזור עליה? (, 1 2 3))
נָכוֹן

=> ;; עובד לתכתיבים
=> (ניתן לשחזר? {:a 1 :b 2 :c 3})
נָכוֹן

=> ;; עובד עבור איטרטורים/גנרטורים
=> (ניתן לחזור עליה? (חזור 3))
נָכוֹן

איטרטור?
נוֹהָג: (איטרטור? x)

החזרים נָכוֹן if x הוא איטרטור. איטרטורים הם אובייקטים המחזירים את עצמם כ-an
איטרטור מתי (איטר x) נקרא. ניגוד עם חזרתיות?.

=> ;; לא עובד עבור רשימה
=> (איטרטור? [1 2 3 4 5])
לא נכון

=> ;; אבל אנחנו יכולים לקבל איטר מהרשימה
=> (איטרטור? (iter [1 2 3 4 5]))
נָכוֹן

=> ;; לא עובד עבור dict
=> (איטרטור? {:a 1 :b 2 :c 3})
לא נכון

=> ;; צור איטרטור מהגזרה
=> (איטרטור? (iter {: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))
נָכוֹן

macroexpand
חדש בגרסה 0.10.0.

נוֹהָג: (מאקרו להרחיב טופס)

מחזירה את הרחבת המאקרו המלאה של טופס.

=> (macroexpand '(-> (a b) (x y)))
(u'x' (u'a' u'b') u'y')

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

macroexpand-1
חדש בגרסה 0.10.0.

נוֹהָג: (macroexpand-1 טופס)

מחזירה את הרחבת המאקרו צעד אחד של טופס.

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

מיזוג-עם
חדש בגרסה 0.10.1.

נוֹהָג: (מיזוג-עם f &מנוחה מפות)

מחזירה מפה המורכבת משאר המפות שהצטרפו אליהן ראשונות. אם מופיע מפתח ב
יותר ממפה אחת, המיפוי(ים) מהאחרון (משמאל לימין) ישולבו עם
המיפוי בתוצאה על ידי קריאה (f val-in-Result val-in-later).

=> (מיזוג עם (fn [x y] (+ x y)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a': 11L, u'c': 30L, u'b': 20L}

נג?
נוֹהָג: (שלילה? x)

החזרים נָכוֹן if x הוא פחות מאפס. מעלה טעות הקלדה if (לא (מספרית? איקס)).

=> (שלילה? -2)
נָכוֹן

=> (שלילה? 3)
לא נכון

=> (שלילה? 0)
לא נכון

אֶפֶס?
נוֹהָג: (אֶפֶס? x)

החזרים נָכוֹן if x is אפס / ללא חתימה.

=> (אפס? אפס)
נָכוֹן

=> (אפס? אין)
נָכוֹן

=> (אפס? 0)
לא נכון

=> (setf x nil)
=> (אפס? x)
נָכוֹן

=> ;; list.append מחזיר תמיד ללא
=> (אפס? (.append [1 2 3] 4))
נָכוֹן

אף אחד?
נוֹהָג: (אף אחד? x)

החזרים נָכוֹן if x is ללא חתימה.

=> (אין? אין)
נָכוֹן

=> (אין? 0)
לא נכון

=> (setf x None)
=> (אין? x)
נָכוֹן

=> ;; list.append מחזיר תמיד ללא
=> (אין? (.append [1 2 3] 4))
נָכוֹן

נ '
נוֹהָג: (נ' קול n &אופציונאלי [בְּרִירַת מֶחדָל אֶפֶס])

מחזירה את nפריט -ה באוסף, סופר מ-0. החזר את ערך ברירת המחדל, אפס, אם
מחוץ לתחום (אלא אם צוין אחרת). מעלה ValueError if n הוא שלילי.

=> (נ' [1 2 4 7] 1)
2

=> (נ' [1 2 4 7] 3)
7

=> (אפס? (nth [1 2 4 7] 5))
נָכוֹן

=> (נ' [1 2 4 7] 5 "ברירת מחדל")
'בְּרִירַת מֶחדָל'

=> (נ' (קח 3 (ירידה 2 [1 2 3 4 5 6])) 2))
5

=> (נ' [1 2 4 7] -1)
Traceback (השיחה האחרונה אחרונה):
...
ValueError: מדדים עבור islice() חייבים להיות None או מספר שלם: 0 <= x <= sys.maxsize.

מספרי?
נוֹהָג: (מספרית? x)

החזרים נָכוֹן if x הוא מספרי, כהגדרתו של Python מספרים.מספר מעמד.

=> (מספרי? -2)
נָכוֹן

=> (מספרי? 3.2)
נָכוֹן

=> (מספרי? "פו")
לא נכון

odd?
נוֹהָג: (מוזר? x)

החזרים נָכוֹן if x הוא מוזר. מעלה טעות הקלדה if (לא (מספרית? איקס)).

=> (מוזר? 13)
נָכוֹן

=> (מוזר? 2)
לא נכון

=> (מוזר? 0)
לא נכון

pos?
נוֹהָג: (פוזי? x)

החזרים נָכוֹן if x גדול מאפס. מעלה טעות הקלדה if (לא (מספרית? איקס)).

=> (מיקום? 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 הוא סמל.

=> (סמל? 'פו)
נָכוֹן

=> (סמל? '[a b c])
לא נכון

אֶפֶס?
נוֹהָג: (אֶפֶס? x)

החזרים נָכוֹן if x הוא אפס.

=> (אפס? 3)
לא נכון

=> (אפס? -2)
לא נכון

=> (אפס? 0)
נָכוֹן

רצף פונקציות
פונקציות רצף יכולות ליצור או לפעול על רצף פוטנציאלי אינסופי ללא
דורש שהרצף יתממש במלואו ברשימה או במיכל דומה. הם עושים זאת על ידי
החזרת איטרטור של Python.

אנו יכולים להשתמש במחולל המספרים האינסופי של פיבונאצ'י הקנוני כדוגמה לשימוש
חלק מהפונקציות הללו.

(defn fib []
(setv a 0)
(setv b 1)
(בעוד שזה נכון
(תשואה א)
(setv (, ab) (, b (+ ab)))))

הערה (בזמן נָכוֹן ...) לוּלָאָה. אם נריץ את זה ב-REPL,

=> (fib)


קריאה לפונקציה מחזירה רק איטרטור, אבל לא עובדת עד שנצרוך אותו.
לנסות משהו כזה לא מומלץ שכן הלולאה האינסופית תפעל עד זה
צורך את כל ה-RAM הזמין, או במקרה הזה עד שהרגתי אותו.

=> (רשימה (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, 1]

=> (רשימה (קח 2 (מחזור [1 2 3])))
[1, 2]

מובהק
נוֹהָג: (מוּבהָק אוסף)

מחזירה איטרטור המכיל רק את האיברים הייחודיים ב קול.

=> (רשימה (מובחן [ 1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (רשימה (מובחן []))
[]

=> (רשימה (מובחן (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

ירידה
נוֹהָג: (יְרִידָה n אוסף)

מחזירה איטרטור, מדלגת על הראשון n חברי קול. מעלה ValueError if n is
שלילי.

=> (רשימה (ירידה 2 [1 2 3 4 5]))
[3, 4, 5]

=> (רשימה (ירידה 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 פריטים ב קול. מעלה ValueError if n is
שלילי.

=> (רשימה (ירידה-אחרון 5 (טווח 10 20)))
[10, 11, 12, 13, 14]

=> (רשימה (ירידה-אחרון 0 (טווח 5)))
[0, 1, 2, 3, 4]

=> (רשימה (ירידה-אחרון 100 (טווח 100)))
[]

=> (יבא את הכלים)
=> (רשימה (קח 5 (ירידה-אחרון 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

ירידה בזמן
נוֹהָג: (ירידה בזמן לפני אוסף)

מחזירה איטרטור, דילוג על חברים של קול עד לפני is לא נכון.

=> (רשימה (ירידה בזמן אפילו? [2 4 7 8 9]))
[7, 8, 9]

=> (רשימה (הורדה בזמן מספרית? [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] (* x x)) 5)))
[5, 25, 625, 390625, 152587890625]

לקרוא
נוֹהָג: (לקרוא &אופציונאלי [מתוך-קובץ eof])

קורא את הביטוי הבא של Hy מ-קובץ (ברירת מחדל ל sys.stdin), ויכול לקחת א
בייט בודד בתור EOF (ברירת המחדל למחרוזת ריקה). מעלה EOFError if מ-קובץ מסתיים לפני
ניתן לנתח ביטוי שלם.

=> (קרא)
(+ 2 2)
('+' 2 2)
=> (eval (קריאה))
(+ 2 2)
4

=> (ייבוא ​​io)
=> (מאגר בהגדרה (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (החל לקרוא [] {"from_file" buffer}))
4
=> (eval (החל לקרוא [] {"from_file" buffer}))
1

=> ; בהנחה ש-"example.hy" מכיל:
=> ; (הדפס "שלום")
=> ; (הדפס "חברים!")
=> (עם [[f (פתח "example.hy")]]
... (נסה
... (אמנם נכון
... (תן [[exp (קרא ו)]]
... (עשה
... (הדפס "OHY" exp)
... (eval exp))))
... (תפוס [EOFError]
... (הדפס "EOF!"))))
OHY ('הדפס' 'שלום')
שלום
OHY ('הדפס' 'חברים!')
חברים!
EOF!

להסיר
נוֹהָג: (לְהַסִיר לפני אוסף)

מחזיר איטרטור מ קול עם אלמנטים שעוברים את הפרדיקט, לפני, הוסר.

ראה גם לסנן.

=> (רשימה (להסיר מוזר? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (רשימה (להסיר פוסט? [1 2 3 4 5 6 7]))
[]

=> (רשימה (להסיר את השלילה? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

לחזור על
נוֹהָג: (חזור x)

מחזירה איטרטור (אינסופי) של x.

=> (רשימה (קח 6 (חזור על "s")))
[אתה, אתה, אתה, אתה, אתה, אתה]

שוב ושוב
נוֹהָג: (שוב ושוב fn)

מחזירה איטרטור על ידי קריאה fn שוב ושוב.

=> (ייבוא ​​[אקראי [randint]])

=> (רשימה (קח 5 (שוב ושוב (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

לקחת
נוֹהָג: (לקחת n אוסף)

מחזירה איטרטור המכיל את הראשון n חברי קול. מעלה ValueError if n is
שלילי.

=> (רשימה (קח 3 [1 2 3 4 5]))
[1, 2, 3]

=> (רשימה (קח 4 (חזור על "s")))
[אתה, אתה, אתה, אתה]

=> (רשימה (קח 0 (חזור על "s")))
[]

לקחת-nth
נוֹהָג: (קח-n' n אוסף)

מחזירה איטרטור המכיל כל n-החבר של קול.

=> (רשימה (take-nth 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (רשימה (take-nth 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (רשימה (take-nth 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (רשימה (take-nth 10 [1 2 3 4 5 6 7]))
[1]

קח תוך כדי
נוֹהָג: (קח-זמן לפני אוסף)

מחזיר איטרטור מ קול כל עוד לפני החזרות נָכוֹן.

=> (רשימה (תיק בזמן? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (רשימה (לקחת בזמן שלילית? [ -4 -3 1 2 5]))
[-4, -3]

=> (רשימה (קח בזמן שלילית? [ 1 2 3 -4 5]))
[]

zipwith
חדש בגרסה 0.9.13.

נוֹהָג: (עם רוכסן fn קול ...)

שווה ערך ל zip, אך משתמש בפונקציה מרובה טיעונים במקום ליצור tuple. אם
zipwith נקרא עם N אוספים, אם כן fn חייב לקבל N טיעונים.

=> (מפעיל ייבוא)
=> (רשימה (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

קורא מאקרו
פקודות מאקרו של קורא מעניקות ל-Lisp את הכוח לשנות ולשנות תחביר תוך כדי תנועה. אתה לא רוצה
סימון פולני? מאקרו קורא יכול לעשות בדיוק את זה. רוצה את הדרך של קלוז'ור לקבל א
רקס? גם פקודות מאקרו של קוראים יכולות לעשות זאת בקלות.

תחביר
=> (מפחזת ^ [expr] (הדפס expr))
=> #^(1 2 3 4)
(1)
=> #^"שלום"
"שלום"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

ל-Hy אין מילולית עבור tuples. בוא נגיד שאתה לא אוהב (, ...) ורוצה משהו אחר. זֶה
היא בעיה שקורא מאקרו מסוגלים לפתור בצורה מסודרת.

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

אתה יכול אפילו לעשות את זה כמו Clojure ויש לי מילולית לביטויים רגולריים!

=> (ייבוא ​​מחדש)
=> (defreader r [expr] `(re.compile ~expr))
=> #r".*"


יישום
משחרר לוקח תו בודד כשם סמל עבור המאקרו של הקורא; כל דבר יותר
יחזיר שגיאה. מבחינת יישום, משחרר מתרחב ללמבדה מכוסה א
מְעַצֵב. מעצב זה שומר את הלמבדה במילון עם שם המודול שלה ו
סמל.

=> (מפחזת ^ [expr] (הדפס expr))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (print expr)))

# מתרחב לתוך (מאקרו_reader_dispatch ...) לאן מועברים הסמל והביטוי
הפונקציה הנכונה.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"שלום"
"שלום"

אזהרה:
בגלל מגבלה ב-lexer ובנתח של Hy, פקודות מאקרו של קורא לא יכולות להגדיר מחדש
תחביר כגון ()[]{}. סביר להניח שזה יטופל בעתיד.

פנימי Hy תיעוד
הערה:
סיביות אלו שימושיות בעיקר עבור אנשים שפורצים ל-Hy עצמו, אך ניתן להשתמש בהם גם עבור
אלה שמתעמקים בתכנות מאקרו.

Hy מודלים
מבוא ל Hy מודלים
דגמי Hy הם שכבה דקה מאוד על גבי אובייקטים רגילים של Python, המייצגים את מקור Hy
קוד כנתונים. מודלים מוסיפים רק מידע על מיקום המקור, וקומץ שיטות
תומך במניפולציה נקייה של קוד מקור Hy, למשל בפקודות מאקרו. כדי להשיג זאת
המטרה, דגמי Hy הם שילובים של מחלקה בסיסית של Python ו HyObject.

HyObject
hy.models.HyObject היא מחלקה הבסיסית של דגמי Hy. הוא מיישם רק שיטה אחת, להחליף,
אשר מחליף את מיקום המקור של האובייקט הנוכחי בזה שהועבר כארגומנט.
זה מאפשר לנו לעקוב אחר המיקום המקורי של ביטויים שמשתנים על ידי
פקודות מאקרו, בין אם זה במהדר או בפקודות מאקרו טהורות.

HyObject לא מיועד לשמש ישירות ליצירת דגמי Hy, אלא רק כמיקסין
לשיעורים אחרים.

תרכובת מודלים
רשימות בסוגריים ומסוגריים מנותחות כמודלים מורכבים על ידי מנתח Hy.

HyList
hy.models.list.HyList היא מחלקה הבסיסית של דגמי Hy "ניתנים למעבר". השימוש הבסיסי שלו הוא ל
מייצגים בסוגריים [] רשימות, אשר, כאשר משתמשים בהן כביטוי ברמה העליונה, מתורגמים ל
רשימת פייתון מילולית בשלב הקומפילציה.

הוספת HyList לאובייקט שניתן לחזור עליו עושה שימוש חוזר במחלקה של האובייקט בצד שמאל,
התנהגות שימושית כאשר אתה רוצה לשרשר אובייקטים Hy במאקרו, למשל.

HyExpression
hy.models.expression.HyExpression יורש HyList לסוגריים () ביטויים. ה
תוצאת הקומפילציה של ביטויים אלה תלויה באלמנט הראשון של הרשימה: ה
מהדר שולח ביטויים בין צורות מיוחדות מהדר, פקודות מאקרו המוגדרות על ידי משתמש ו
קריאות רגילות לפונקציות Python.

HyDict
hy.models.dict.HyDict יורש HyList לסוגריים מתולתלים {} ביטויים, אשר קומפילציה
עד למילון פייתון מילולי.

ההחלטה להשתמש ברשימה במקום בדקט כמחלקת הבסיס עבור HyDict מאפשר קל יותר
מניפולציה של dictates בפקודות מאקרו, עם היתרון הנוסף של התרת ביטויים מורכבים
כמפתחות dict (כמו, למשל, ה HyExpression מחלקת Python אינה ניתנת לגיבוש).

אטומי מודלים
בזרם הקלט, מחרוזות במירכאות כפולות, המכבדות את סימון ה-Python עבור מחרוזות,
מנותחים כאסימון יחיד, אשר מנותח ישירות כ-a HyString.

מחרוזת תווים ללא הפרעה, לא כולל רווחים, סוגריים, גרשיים, גרשיים כפולים
והערות, מנותח כמזהה.

מזהים נפתרים למודלים אטומיים במהלך שלב הניתוח בסדר הבא:

· HyInteger

· HyFloat

· HyComplex (אם האטום אינו חשוף j)

· HyKeyword (אם האטום מתחיל עם :)

· HySymbol

HyString
hy.models.string.HyString היא מחלקה הבסיסית של דגמי Hy המקבילים למיתר. זה גם
מייצג מילולי מחרוזת במירכאות כפולות, "", אשר קומפילציה למחרוזת Unicode
מילוליות בפייתון. HyStrings יורש אובייקטי Unicode ב- Python 2, ועצמי מחרוזת ב
Python 3 (ולכן אינם תלויי קידוד).

HyString מודלים מבוססים אינם ניתנים לשינוי.

מחרוזות מילוליות יכולות להשתרע על פני מספר שורות, ונחשבות על ידי המנתח כיחידה
unit, תוך מתן כבוד ל-Python Escapes עבור מחרוזות Unicode.

מספרי מודלים
hy.models.integer.HyInteger מייצג מילים שלמים (באמצעות ה- ארוך הקלד על פייתון 2,
ו int על פייתון 3).

hy.models.float.HyFloat מייצג מילולי נקודה צפה.

hy.models.complex.HyComplex מייצג מילים מורכבות.

מודלים מספריים מנותחים באמצעות שגרת Python המתאימה, ופיתון מספרי חוקי
מילוליים יהפכו למקבילם Hy.

HySymbol
hy.models.symbol.HySymbol הוא המודל המשמש לייצוג סמלים בשפת Hy. זה
יורש HyString.

HySymbol אובייקטים מעוותים בשלב הניתוח, כדי לעזור לפעולה הדדית של Python:

· סמלים מוקפים בכוכביות (*) הופכים לאותיות רישיות;

· מקפים (-) הופכים לקו תחתון (_);

· סימן שאלה אחד עוקב (?) הופך למוביל הוא_.

אזהרה: מכיוון שהמנגלינג מתבצע בשלב הניתוח, אפשר
יצירת HySymbols באופן פרוגרמטי שלא ניתן ליצור עם קוד מקור Hy. כמו
המנגנון משמש את gensym ליצירת סמלים "לא מובנים".

HyKeyword
hy.models.keyword.HyKeyword מייצג מילות מפתח ב-Hy. מילות מפתח הן סמלים שמתחילים ב
a :. הכיתה יורשת HyString.

להבחין HyKeywords החל מ- HySymbols, ללא אפשרות של (לא רצוני)
התנגשויות, תו ה-unicode לשימוש פרטי "\uFDD0" מונח לפני מילת המפתח מילולית
לפני האחסון.

חסרונות תאים
hy.models.cons.HyCons הוא ייצוג של Python ידידותי חסרונות תאים. חסרונות תאים הם
שימושי במיוחד כדי לחקות תכונות של גרסאות LISP "רגילות" כגון Scheme או Common
עִלְגוּת.

תא חסרונות הוא אובייקט בן 2 פריטים, המכיל א מכונית (ראש) וא cdr (זָנָב). באיזו ליספ
וריאנטים, תא החסרונות הוא אבן הבניין הבסיסית, וביטויי S הם למעשה
מיוצג כרשימות מקושרות של תאי חסרונות. זה לא המצב ב-Hy, כרגיל
ביטויים עשויים מרשימות Python עטופות ב-a HyExpression. אולם, ה HyCons
מחקה את ההתנהגות של גרסאות Lisp "הרגילות" כך:

· (חסרונות משהו אֶפֶס) is (HyExpression [משהו])

· (חסרונות משהו רשימה כלשהי) is ((סוּג רשימה כלשהי) (+ [משהו] רשימה כלשהי)) (אם
רשימה כלשהי יורש מ רשימה).

· (לקבל (חסרונות a b) 0) is a

· (פרוסה (חסרונות a b) 1) is b

Hy תומך בתחביר של רשימה מנוקדת, שבו '(א . b) אומר (חסרונות 'a 'ב) ו '(א b . c) אומר
(חסרונות 'a (חסרונות 'b 'ג)). אם המהדר נתקל בתא חסרונות ברמה העליונה, הוא מעלה
שגיאת קומפילציה.

HyCons עוטף את הטיעונים שעברו (car ו-cdr) בסוגי Hy, כדי להקל על המניפולציה של
תאי חסרונות בהקשר מאקרו.

Hy פנימי תֵאוֹרִיָה
סקירה כללית
הרכיבים הפנימיים של Hy פועלים כחזית קצה של Python bytecode, כך ש-Hy עצמו
קומפילציה עד Python Bytecode, ומאפשרת לזמן ריצה של Python ללא שינוי להריץ קוד Hy,
אפילו בלי לשים לב לזה.

הדרך בה אנו עושים זאת היא על ידי תרגום Hy למבנה נתונים פנימי של Python AST, ו
בניית ה-AST הזה לתוך Python bytecode באמצעות מודולים מתקן Python
ספרייה, כדי שלא נצטרך לשכפל את כל העבודה של ה-Python הפנימיות עבור כל אחד
שחרור יחיד של Python.

הוא עובד בארבעה שלבים. הסעיפים הבאים יכסו כל שלב של Hy ממקור עד
זמן ריצה.

צעדים 1 ו 2: אסימון ו ניתוח
השלב הראשון של קומפילציה של Hy הוא העברת המקור לאסימונים שנוכל להתמודד איתם. אָנוּ
השתמש בפרויקט בשם rply, שהוא מנתח ממש נחמד (ומהיר), שנכתב בתת-קבוצה
של Python שנקרא rpython.

כל קוד lexing מוגדר ב hy.lex.lexer. הקוד הזה בעיקר מגדיר את ה-Hy
דקדוק, וכל החלקים הקשים בפועל מטופלים על ידי rply -- אנחנו רק מגדירים
"התקשרות חוזרת" עבור rply in hy.lex.parser, שלוקח את האסימונים שנוצרו, ומחזיר את
דגמים היי.

אתה יכול לחשוב על דגמי Hy כעל ה"AST" עבור Hy, זה מה שמאקרו פועלים עליו
(ישירות), וזה מה שהמהדר משתמש כשהוא מקמפל Hy down.

לִרְאוֹת גַם:
סעיף Hy מודלים למידע נוסף על דגמי Hy ומה משמעותם.

שלב 3: Hy Compilation ל פיתון AST
זה המקום שבו מתרחש רוב הקסם בהי. זה המקום שבו אנחנו לוקחים את Hy AST (הדגמים),
והידור אותם לתוך Python AST. קורים כאן כמה דברים מצחיקים שעובדים מעבר לכמה
בעיות ב-AST, ועבודה במהדר היא חלק מהעבודות החשובות ביותר שאנו עושים
יש לי.

הקומפיילר קצת מורכב, אז אל תרגיש רע אם אתה לא מחטט אותו בצילום הראשון,
זה עשוי לקחת קצת זמן כדי להסתדר.

נקודת הכניסה העיקרית לקומפיילר היא HyASTCompiler.compile. שיטה זו מופעלת, ו
השיטה ה"ציבורית" האמיתית היחידה בכיתה (כלומר, אנחנו לא באמת מבטיחים את
API מעבר לשיטה זו).

למעשה, אפילו פנימית, אנחנו לא חוזרים ישירות כמעט אף פעם, אנחנו כמעט תמיד מכריחים
עץ Hy דרך לעבד, ולעתים קרובות יעשה זאת עם תת-אלמנטים של ביטוי
שיש לנו. זה תלוי בשולח המבוסס על סוגים לשגר כראוי תת-אלמנטים.

כל השיטות שיוצרות קומפילציה מסומנות ב- @builds() מְעַצֵב. אתה יכול
או לעבור את המחלקה של מודל Hy שהוא קומפילציה, או שאתה יכול להשתמש במחרוזת עבור
ביטויים. אני אבהיר את זה בעוד שנייה.

ראשון התמחות סוג-שיגור
בואו נתחיל ב לעבד שיטה. הדבר הראשון שאנו עושים הוא לבדוק את סוג הדבר
אנחנו בונים. אנחנו מסתכלים למעלה כדי לראות אם יש לנו שיטה שיכולה לבנות את סוּג() שאנחנו
יש, ולשלוח לשיטה שיכולה להתמודד עם זה. אם אין לנו שיטות שיכולות
לבנות את הסוג הזה, אנחנו מעלים פנימית חריגה.

לדוגמה, אם יש לנו א HyString, יש לנו מיפוי כמעט 1 ל-1 של Hy AST לפייתון
AST. ה קומפיל_מחרוזת השיטה לוקחת את HyString, ומחזירה an ast.Str()
מאוכלס במספרי השורות ובתוכן הנכונים.

מאקרו-הרחבה
אם נקבל א HyExpression, ננסה לראות אם זה מאקרו ידוע, ונדחף לקבל
זה התרחב על ידי פנייה hy.macros.macroexpand, ואז לדחוף את התוצאה בחזרה לתוך
HyASTCompiler.compile.

שְׁנִיָה התמחות ביטוי-שיגור
המקרה המיוחד היחיד הוא HyExpression, מכיוון שעלינו ליצור AST שונה בהתאם
בטופס המיוחד המדובר. לדוגמה, כאשר אנו מכים an (אם נָכוֹן נָכוֹן שקר), אנחנו
צריך ליצור א ast.If, והידור נכון של תת-הצמתים. זה המקום שבו ה @builds()
עם String כטיעון נכנס.

כדי להתאים הידור_ביטוי (אשר מוגדר עם an @builds(HyExpression)) ישלח
מבוסס על המחרוזת של הארגומנט הראשון. אם, מסיבה כלשהי, הטיעון הראשון לא
מחרוזת, הוא יטפל כראוי גם במקרה הזה (ככל הנראה על ידי העלאת an חריגה).

אם המחרוזת אינה מוכרת ל-Hy, היא תיצור כברירת מחדל ast.Call, אשר ינסה
לעשות שיחת זמן ריצה (ב-Python, משהו כמו foo ()).

נושאים מכה עם פיתון AST
Python AST נהדר; זה מה שאפשר לנו לכתוב פרויקט כל כך חזק על גבי
פייתון מבלי להילחם בפייתון חזק מדי. כמו כל דבר, היה לנו חלק נכבד של
בעיות, והנה רשימה קצרה של הבעיות הנפוצות שאתה עלול להיתקל בהן.

פיתון ההבחנה שעושה בֵּין דוחות ו ביטויים.

זה אולי לא נשמע כמו עניין גדול -- למעשה, לרוב מתכנתי Python, זה יעשה זאת
בקרוב הפך לרגע "נו, כן".

ב-Python, לעשות משהו כמו:

הדפסה ל x in רכס(10): לעבור, כי הדפסה מדפיס ביטויים, ו ל אינו
ביטוי, זו הצהרת זרימת בקרה. דברים כמו 1 + 1 הם ביטויים, כפי שהם למבדה
x: 1 + x, אבל תכונות שפה אחרות, כגון if, ל, או בזמן הן הצהרות.

מכיוון שאין להם "ערך" לפייתון, זה הופך את העבודה ב-Hy לקשה, מאז לעשות משהו
כמו (הדפס (אם נָכוֹן נָכוֹן שֶׁקֶר)) זה לא רק נפוץ, זה צפוי.

כתוצאה מכך, אנו מעכלים דברים באופן אוטומטי באמצעות a תוֹצָאָה אובייקט, שבו אנו מציעים כל ast.stmt
שצריך לרוץ, וסינגל ast.expr שניתן להשתמש בו כדי לקבל את הערך של כל דבר
פשוט הופעל. Hy עושה זאת על ידי כפיית הקצאה לדברים תוך כדי ריצה.

כדוגמה, ה-Hy:

(הדפס (אם נכון נכון לא נכון))

יהפוך ל:

אם זה נכון:
_mangled_name_here = נכון
else
_mangled_name_here = לא נכון

הדפס את _שם_מעופש_כאן

בסדר, זה היה קצת שקר, מכיוון שאנו למעשה הופכים את ההצהרה הזו ל:

-- נכון אם נכון אחר לא נכון

על ידי כפיית דברים לתוך א ast.expr אם אנחנו יכולים, אבל הרעיון הכללי מתקיים.

שלב 4: פיתון קוד בתים תְפוּקָה ו זמן ריצה
לאחר שיש לנו עץ Python AST שהושלם, נוכל לנסות ולהרכיב אותו לפייתון
bytecode על ידי דחיפתו הערכה. מכאן ואילך, אנחנו כבר לא בשליטה, ו
פייתון דואג להכל. זו הסיבה שדברים כמו פייתון tracebacks, pdb ו
אפליקציות django עובדות.

Hy מאקרו
שימוש gensym ל בטוח יותר מאקרו
בעת כתיבת פקודות מאקרו, יש להקפיד להימנע מלכידת משתנים חיצוניים או שימוש
שמות משתנים שעלולים להתנגש עם קוד המשתמש.

נשתמש במאקרו לדוגמה NIF (ראה
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 לתיאור מלא יותר.)
NIF הוא דוגמה, משהו כמו מספרי if, כאשר בהתבסס על הביטוי, אחד מה
3 צורות נקראות תלוי אם הביטוי חיובי, אפס או שלילי.

מעבר ראשון עשוי להיות משהו כמו:

(defmacro nif [expr pos-form zero-form neg-form]
`(תן [[שם לא ברור ~expr]]
(cond [(pos? לא ברור-שם) ~pos-form]
[(אפס? שם לא ברור) ~צורת אפס]
[(שלילה? שם לא ברור) ~צורת שלילי])))

איפה שם סתומים הוא ניסיון לבחור שם משתנה כלשהו כדי לא להתנגש עם אחר
קוד. אבל כמובן, למרות כוונות טובות, זה לא ערובה.

השיטה gensym נועדה ליצור סמל חדש וייחודי בדיוק לאירוע כזה.
גרסה הרבה יותר טובה של NIF יהיה:

(defmacro nif [expr pos-form zero-form neg-form]
(תן [[g (gensym)]]
`(תנו [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(אפס? ~g) ~צורת אפס]
[(שלילה? ~ז') ~צורת שלילי]))))

זהו מקרה קל, שכן יש רק סמל אחד. אבל אם יש צורך בכמה
gensym's יש מאקרו שני עם gensyms שבעצם מתרחב לסדרה של לתת
הצהרות:

(עם-gensyms [a b c]
...)

מתרחב ל:

(תן [[a (gensym)
[b (gensym)
[c (gensym)]]
...)

אז שלנו נכתב מחדש NIF ייראה כמו:

(defmacro nif [expr pos-form zero-form neg-form]
(עם-gensyms [g]
`(תנו [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(אפס? ~g) ~צורת אפס]
[(שלילה? ~ז') ~צורת שלילי]))))

לבסוף, למרות שאנו יכולים ליצור מאקרו חדש שעושה את כל זה עבורנו. defmacro/g! ייקח
כל הסמלים שמתחילים בהם g! ולהתקשר אוטומטית gensym עם שאר ה
סֵמֶל. כך ג!א יהפוך (gensym "א").

הגרסה הסופית שלנו של NIF, בנוי עם 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 מהדר מובנה

משתתף מודולים מדד

תוכן:

אנפורית מאקרו
חדש בגרסה 0.9.12.

מודול המאקרו האנפורי הופך את התכנות הפונקציונלי ב-Hy לתמצית מאוד וקל לביצוע
לקרוא.
מאקרו אנפורי הוא סוג של מאקרו תכנות הלוכד צורה כלשהי בכוונה
מסופק למקרו שאליו ניתן להתייחס באמצעות אנפורה (ביטוי המתייחס
לאחר). - ויקיפדיה (http://en.wikipedia.org/wiki/Anaphoric_macro)

מאקרו
ap-if
נוֹהָג: (ap-if (פו) (הדפס זה))

מעריך את הצורה הראשונה לאמיתות, ומקשר אותה אליה it גם בשקר וגם בשקר
ענפים.

אפרסק
נוֹהָג: (אפרסק [1 2 3 4 5] (הדפס זה))

הערך את הטופס עבור כל רכיב ברשימה עבור תופעות לוואי.

אפ-כל-זמן
נוֹהָג: (אפ-כל-זמן רשימה לפני גוּף)

הערך את הטופס עבור כל רכיב שבו טופס הפרדיקט חוזר נָכוֹן.

=> (ap-each-while [1 2 3 4 5 6] (< it 4) (הדפס אותו))
1
2
3

ap-map
נוֹהָג: (ap-map טופס רשימה)

הצורה האנפורית של המפה פועלת בדיוק כמו מפה רגילה, פרט לכך במקום פונקציה
לאובייקט הוא מקבל צורת Hy. השם המיוחד it קשור לאובייקט הנוכחי מה-
רשימה באיטרציה.

=> (רשימה (ap-map (* it 2) [1 2 3]))
[2, 4, 6]

ap-map-when
נוֹהָג: (ap-map-when predfn נציג רשימה)

הערך מיפוי על פני הרשימה באמצעות פונקציית פרדיקט כדי לקבוע מתי להחיל את
הטופס.

=> (רשימה (ap-map-when odd? (* 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-filter
נוֹהָג: (אפ-פילטר טופס רשימה)

כמו עם ap-map אנו לוקחים צורה מיוחדת במקום פונקציה לסינון האלמנטים של
רשימה. השם המיוחד it קשור לאלמנט הנוכחי באיטרציה.

=> (רשימה (ap-filter (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]

ap-reject
נוֹהָג: (אפ-דחייה טופס רשימה)

פונקציה זו עושה את ההיפך מ ap-filter, הוא דוחה את האלמנטים העוברים את
פרידיקט . השם המיוחד it קשור לאלמנט הנוכחי באיטרציה.

=> (רשימה (ap-reject (> (* it 2) 6) [1 2 3 4 5]))
[1, 2, 3]

ap-dotimes
נוֹהָג (ap-dotimes n גוּף)

פונקציה זו מעריכה את הגוף n פעמים, עם המשתנה המיוחד it קשור מ 0 ל
1-נ. זה שימושי עבור תופעות לוואי.

=> (מסך n [])
=> (ap-dotimes 3 (.append n it))
=> נ
[0, 1, 2]

ap-first
נוֹהָג (ap-first predfn רשימה)

פונקציה זו מחזירה את האלמנט הראשון שעובר את הפרדיקט או ללא חתימהעם
משתנה מיוחד it קשור לאלמנט הנוכחי באיטרציה.

=>(ap-first (> it 5) (טווח 10))
6

ap-last
נוֹהָג (ap-last predfn רשימה)

פונקציה זו מחזירה את האלמנט האחרון שעובר את הפרדיקט או ללא חתימה, עם המיוחד
משתנה it קשור לאלמנט הנוכחי באיטרציה.

=>(ap-last (> it 5) (טווח 10))
9

ap-reduce
נוֹהָג (ap-reduce טופס רשימה &אופציונאלי ערך התחלתי)

פונקציה זו מחזירה את התוצאה של החלת טופס על 2 האלמנטים הראשונים בגוף ו
החלת התוצאה והאלמנט השלישי וכו' עד למיצוי הרשימה. אופציונלי א
ניתן לספק ערך התחלתי כך שהפונקציה תיושם על הערך ההתחלתי וה-
אלמנט ראשון במקום. זה חושף את האלמנט שנחזר בתור it ואת הזרם
ערך מצטבר כ ACC.

=>(ap-reduce (+ it acc) (טווח 10))
45

לולאה / חוזרת
חדש בגרסה 0.10.0.

אל האני לולאה / לחזור מאקרו נותן למתכנתים דרך פשוטה להשתמש באופטימיזציה של שיחות זנב (TCO)
בקוד ה-Hy שלהם.
שיחת זנב היא שיחת תת שגרתית המתרחשת בתוך הליך אחר כסופי שלה
פעולה; הוא עשוי להפיק ערך החזרה אשר לאחר מכן מוחזר מיד על ידי הקריאה
תהליך. אם כל שיחה שתת-שגרה מבצעת, כזו שהיא עלולה להוביל בסופו של דבר
לאותה תת-שגרה שנקראת שוב בהמשך שרשרת השיחה, נמצאת בתנוחת זנב,
אומרים שתת שגרה כזו היא רקורסיבית זנב, שזה מקרה מיוחד של רקורסיה.
קריאות זנב הן משמעותיות מכיוון שניתן ליישם אותן מבלי להוסיף מחסנית חדשה
מסגרת לערימת השיחות. רוב המסגרת של ההליך הנוכחי אין צורך בכלל
יותר, והוא יכול להיות מוחלף על ידי המסגרת של הקריאה הזנב. לאחר מכן התוכנית יכולה לקפוץ
לתת-השגרה הנקראת. הפקת קוד כזה במקום רצף שיחות רגיל הוא
שנקרא חיסול שיחות זנב, או אופטימיזציה של שיחות זנב. ביטול שיחת זנב מאפשר
הנוהל קורא ליישם את עמדת הזנב ביעילות כמו הצהרות goto,
ובכך לאפשר תכנות מובנה יעיל. - ויקיפדיה (-
http://en.wikipedia.org/wiki/Tail_call)

מאקרו
לולאה
לולאה קובע נקודת רקורסיה. עם לולאה, לחזור קושר מחדש את המשתנים המוגדרים ב-
נקודת רקורסיה ושולחת ביצוע קוד בחזרה לאותה נקודת רקורסיה. אם לחזור משמש
עמדה ללא זנב, חריג נזרק.

נוֹהָג: (לוּלָאָה כריכות &מנוחה גוּף)

דוגמא:

(דרוש hy.contrib.loop)

(הגדרת פקטורי [n]
(לולאה [[i n] [acc 1]]
(אם (אפס? אני)
ACC
(חוזר (דחות i) (* acc i)))))

(פקטורי 1000)

defmulti
חדש בגרסה 0.10.0.

defmulti מאפשר לך להעמיס יתר על המידה על פונקציה במספר נתון של args ו/או kwargs.
בהשראת הטייק על של Clojure defn.

=> (דרוש hy.contrib.multi)
=> (בדיוק כיף
... ([א] "א")
... ([א ב] "א ב")
... ([a b c] "a b c"))
=> (כיף 1)
"א"
=> (כיף 1 2)
"א ב"
=> (כיף 1 2 3)
"א ב ג"

פריצה ON HY

לְהִצְטַרֵף שלנו היווה!
בבקשה בוא לפרוץ Hy!

בבקשה בוא לבלות איתנו #היי on irc.freenode.net!

אנא דבר על זה בטוויטר עם #היי סולמית!

בבקשה בלוג על זה!

נא לא לרסס אותו על הגדר של השכן (בלי לבקש יפה)!

גַרזֶן!
תעשה את זה:

1. ליצור וירטואלי סביבה:

$ virtualenv venv

והפעל אותו:

$ . venv/bin/activate

או שימוש virtualenvwrapper כדי ליצור ולנהל את הסביבה הוירטואלית שלך:

$ mkvirtualenv hy
$ עבודה על היי

2. קבל את קוד המקור:

שיבוט $ git https://github.com/hylang/hy.git

או השתמש במזלג שלך:

שיבוט $ git [מוגן בדוא"ל]:/hy.git

3. התקן עבור פריצה:

$ cd hy/
$ pip התקנת -e .

4. התקן דרישות פיתוח אחרות:

$ pip התקנת -r requirements-dev.txt

5. עשה דברים מדהימים; לגרום למישהו לצרוח בהנאה/גועל נפש ממה שעשית.

מבחן!
הבדיקות ממוקמות ב מבחנים /. אנו משתמשים אף.

כדי להריץ את הבדיקות:

$ בדיקות אף

כתוב מבחנים --- מבחנים זה טוב!

כמו כן, טוב להריץ את הבדיקות עבור כל הפלטפורמות הנתמכות ועבור תואם PEP 8
קוד. אתה יכול לעשות זאת על ידי הפעלת טוקס:

רעל דולר

מסמך!
התיעוד נמצא ב מסמכים/. אנו משתמשים ספינקס.

כדי לבנות את המסמכים ב-HTML:

$ cd docs
$ לעשות html

כתוב מסמכים --- מסמכים טובים! אפילו הדוקטור הזה!

תרומה
תרומות יתקבלו בברכה ומוערכות מאוד, כל מעט עוזר בהפיכת Hy ליותר
מדהים.

בקשות משיכה נהדרות! אנחנו אוהבים אותם; הנה מדריך קצר:

· מזלג את הריפו וצור ענף נושא עבור תכונה/תיקון. הימנע מביצוע שינויים ישירות
על ענף המאסטר.

· כל התכונות הנכנסות צריכות להיות מלווה בבדיקות.

· לפני שאתה שולח יח"צ, בבקשה הרץ את הבדיקות ובדוק את הקוד שלך מול הסגנון
להנחות. אתה יכול לעשות את שני הדברים האלה בבת אחת:

$ לעשות ד

· הפוך התחייבויות ליחידות לוגיות, כך שיהיה קל יותר לעקוב ולנווט מאוחר יותר. לפני
הגשת יחסי ציבור, נסה לדחוס את המחויבויות לשינויים שקל לחזור אליהם
יותר מאוחר. כמו כן, ודא שאינך משאיר רווח לבן מזויף בערכות השינויים; זֶה
נמנע מיצירת פעולות לתיקון רווחים לבנים מאוחר יותר.

· בכל הנוגע להודעות התחייבות, נסה לדבוק בדברים הבאים:

· נסה לדבוק במגבלת 50 התווים עבור השורה הראשונה של הודעות Git commit.

· לפרטים נוספים/הסברים, עקוב אחר זה בשורה ריקה והמשך
מתאר את ההתחייבות בפירוט.

· לבסוף, הוסף את עצמך לקובץ AUTHORS (כמחוייבות נפרדת): מגיע לך :)

· כל השינויים הנכנסים צריכים להיות מאושרים על ידי 2 חברים שונים בצוות הליבה של Hylang.
סקירה נוספת תתקבל בברכה, אך אנו זקוקים למינימום של 2 סימנים לכל אחת
לשנות.

· אם חבר ליבה שולח יח"צ, אנא מצא 2 חברי ליבה שאינם כוללים את
מגיש יחסי ציבור. הרעיון כאן הוא שאפשר לעבוד עם מחבר היח"צ, ושנייה מודה
כל סט השינויים.

· לתיעוד ושינויים טריוויאליים אחרים, כדאי לנו למזג אחרי ACK אחד. יש לנו
כיסוי נמוך, אז זה יהיה נהדר לשמור על מחסום נמוך.

ליבה קְבוּצָה
צוות הפיתוח הליבה של Hy מורכב מהמפתחים הבאים:

· ג'וליאן דנג'ו

· מורטן לינדרוד

· J קנת המלך

· בחום Nagy

· טובאקה טורטו

· קארן רוסטאד

· Abhishek L

· כריסטופר אלן וובר

· קונרד הינסן

· רצון קאהן-גרין

· פול טגליאמונטה

· ניקולא דנדרימונט

· שילינג טולברט

· ברקר פקסג

· קלינטון N. דרייסבך

· הוא semaj

השתמש ב-hy באינטרנט באמצעות שירותי onworks.net