hy - Интернет в облаке

ПРОГРАММА:

ИМЯ

hy - hy Документация [изображение: Hy] [изображение]

Попытка Hy https://try-hy.appspot.com

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

Источник https://github.com/hylang/hy

Список хиланг-обсуждение

IRC #хй на Freenode

строить статус
Трэвис CI.НЕИНДЕНТ

Hy - замечательный диалект Лиспа, встроенный в Python.

Поскольку Hy преобразует свой код Lisp в абстрактное синтаксическое дерево Python, у вас есть
весь прекрасный мир Python у вас под рукой, в форме Lisp!

Содержание:

БЫСТРЫЙ СТАРТ

[изображение: Объятия Карен Растард] [изображение]

(Спасибо Карен Рустад за Cuddles!)

КАК МЫ РАБОТАЕМ К ПОЛУЧИТЬ HY РЕАЛ БЫСТРО:

1. Создать Виртуальный Питон Окружающая среда.

2. Активируйте вашу виртуальную среду Python.

3. Устанавливать hy от PyPI типун устанавливать hy.

4. Запустите REPL с hy.

5. Введите в REPL что-нибудь:

=> (выведите «Хи!»)
Hy!
=> (defn salutationsnm [name] (print (+ "Hy" name "!")))
=> (salutationsnm "Ваше имя")
Привет Твое Имя!

и т.д

6. Когда закончите, нажмите CTRL-D.

OMG! Это удивительно! I хотеть в записывать a Hy программу.

7. Откройте элитный редактор программирования и введите:

(напечатайте «Я собирался писать код на синтаксисе Python, но потом у меня появился Хай»).

8. Сохранить как офигенно.хи.

9. И запустите вашу первую программу Hy:

о, круто.

10.
Сделайте глубокий вдох, чтобы не было гипервентиляции.

11.
Злобно улыбайтесь, крадитесь в свой hydeaway и творите ужасные вещи.

Обучение

Добро пожаловать в руководство по Hy!

Короче говоря, Hy - это диалект Лиспа, но тот, который преобразует его структуру в Python ...
буквально преобразование в абстрактное синтаксическое дерево Python! (Или положить его в более грубый
терминами, Hy - это шепот на Python!)

Это довольно круто, потому что это означает, что Хай - это несколько вещей:

· Lisp, который кажется очень питоническим

· Для Лисперов - отличный способ использовать безумные возможности Лиспа, но в широком мире Python
библиотеки (почему да, теперь вы можете написать приложение Django на Lisp!)

· Для питонистов - отличный способ начать изучать Лисп, не выходя из Python!

· Для всех: приятный язык, в котором много интересных идей!

Базовый введение в Лепет для питонисты
Хорошо, возможно, вы никогда раньше не использовали Lisp, но вы использовали Python!

Программа "hello world" в Hy на самом деле очень проста. Давай попробуем:

(выведите «привет, мир»)

Видеть? Легкий! Как вы уже догадались, это то же самое, что и версия для Python:

напечатать "привет, мир"

Чтобы сложить сверхпростую математику, мы могли бы сделать:

(+1)

Что вернет 4 и будет эквивалентом:

1 + 3

Вы заметите, что первым элементом в списке является вызываемая функция, а
остальные аргументы - это передаваемые аргументы. Фактически, в Hy (как и в большинстве
Lisps), мы можем передать несколько аргументов оператору плюс:

(+ 1 3 55)

Что вернет 59.

Возможно, вы слышали о Лиспе раньше, но мало о нем знаете. Лисп не так сложен, как ты
может подумать, а Hy унаследован от Python, поэтому Hy - отличный способ начать изучать Лисп.
Главное, что очевидно в Лиспе, - это то, что в нем много круглых скобок. Это может
сначала кажется запутанным, но это не так уж и сложно. Давайте посмотрим на простую математику, которая
заключенный в кучу круглых скобок, которые мы могли бы ввести в интерпретатор Hy:

(setv результат (- (/ (+ 1 3 88) 2) 8))

Это вернет 38. Но почему? Что ж, мы могли бы взглянуть на эквивалентное выражение в
питон:

результат = ((1 + 3 + 88) / 2) - 8

Если бы вы попытались выяснить, как вышеуказанное должно работать в Python, вы бы, конечно,
выяснить результаты, решив каждую внутреннюю скобку. Это та же основная идея в
Hy. Давайте сначала попробуем это упражнение на Python:

результат = ((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))
; упрощено до ...
(setv результат 38)

Как вы, наверное, догадались, это последнее выражение с сетв означает присвоить переменную
«результат» до 38.

Видеть? Не так уж сложно!

Это основная предпосылка Lisp. Lisp означает «обработка списка»; это означает, что
Структура программы - это фактически списки списков. (Если вы знакомы с Python
списки, представьте себе всю ту же структуру, что и выше, но вместо этого с квадратными скобками, любые
вы сможете увидеть вышеупомянутую структуру и как программу, и как структуру данных.)
легче понять с большим количеством примеров, поэтому давайте напишем простую программу Python, протестируем ее,
а затем покажите эквивалентную программу Hy:

def simple_conversation ():
print "Здравствуйте! Я хочу познакомиться с вами. Расскажите о себе!"
name = raw_input ("Как вас зовут?")
age = raw_input ("Сколько вам лет?")
напечатайте "Hello" + name + "! Я вижу, вам" + age + "лет."

simple_conversation ()

Если бы мы запустили эту программу, она могла бы выглядеть так:

Привет! Я бы хотел узнать тебя. Расскажи мне о себе!
Как Вас зовут? Гэри
Сколько тебе лет? 38
Привет, Гэри! Я вижу, тебе 38 лет.

Теперь посмотрим на эквивалентную программу Hy:

(определение простой-беседы []
(печать «Здравствуйте! Я хочу познакомиться с вами. Расскажите о себе!»)
(setv name (raw-input "Как вас зовут?"))
(setv age (raw-input "Сколько вам лет?"))
(print (+ "Привет" имя "! Я тебя вижу"
возраст "лет.")))

(простой разговор)

Если вы посмотрите на приведенную выше программу, если вы помните, что первый элемент в каждом
список программы - это вызываемая функция (или макрос ... мы вернемся к ним позже)
и что все остальное - аргументы, довольно легко понять, что все это означает.
(Как вы, наверное, тоже догадались, определение - это метод определения методов Hy.)

Тем не менее, многих людей это сначала сбивает с толку, потому что здесь так много скобок,
но есть много вещей, которые могут упростить эту задачу: сделать отступы красивыми и
используйте редактор с соответствием круглых скобок (это поможет вам выяснить, что каждый
скобки соединяются с), и все станет более комфортно.

Есть некоторые преимущества в структуре кода, которая на самом деле представляет собой очень простые данные.
структура как ядро ​​Lisp основана на. Во-первых, это означает, что ваши программы
легко анализировать и что вся фактическая структура программы очень четко представлена
тебе. (В hy есть дополнительный шаг, на котором структура, которую вы видите, преобразуется в Python
собственные представления ... в "более чистых" Лиспах, таких как Common Lisp или Emacs Lisp, данные
структура, которую вы видите в коде, и структура данных, которая выполняется, намного больше
буквально близко.)

Еще одно следствие этого - макросы: если структура программы представляет собой простые данные
структура, это означает, что вы можете написать код, который может писать код очень легко, а это означает, что
внедрение совершенно новых языковых функций может быть очень быстрым. До Хай этого не было
очень возможно для программистов Python ... теперь вы тоже можете использовать невероятные макросы
мощность (только будьте осторожны, чтобы не направить их в ногу)!

Hy is a Со вкусом лиспа Питон
Hy преобразуется в собственное абстрактное синтаксическое дерево Python, поэтому вы скоро обнаружите, что все
знакомая сила Python у вас под рукой.

У вас есть полный доступ к типам данных Python и стандартной библиотеке в Hy. Давай поэкспериментируем
с этим в интерпретаторе hy:

=> [1 2 3]
[1, 2, 3]
=> {"собака" "лает"
... "кот" "мяу"}
...
{'собака': 'лай', 'кошка': 'мяу'}
=> (, 1 2 3)
(1, 2, 3)

Если вы знакомы с другими Lisps, вам может быть интересно, что Hy поддерживает Common
Лисп-метод цитирования:

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

У вас также есть доступ ко всем красивым методам встроенных типов:

=> (.strip "fooooo")
"фооооо"

Что это? Да, действительно, это то же самое, что:

"fooooo" .strip ()

Правильно - Лисп с точечной нотацией! Если у нас есть эта строка, назначенная как переменная, мы
также может делать следующее:

(установить эту строку "fooooo")
(эта-строка.полоса)

А как насчет условных выражений ?:

(если (попробуй что-нибудь)
(выведите «это если правда»)
(выведите «это если ложь»))

Как вы можете сказать выше, первый аргумент if это проверка истинности, второй аргумент
тело, если истина, и третий аргумент (необязательно!), если ложь (т. е. еще).

Если вам нужно сделать более сложные условные выражения, вы обнаружите, что у вас нет Элиф
доступно в Hy. Вместо этого вы должны использовать что-то под названием конд. В Python вы можете сделать
что-то вроде:

коевар = 33
если somevar> 50:
print "Эта переменная слишком велика!"
Элиф Сомвар <10:
print "Эта переменная слишком мала!"
еще:
print "Эта переменная верна!"

В Hy вы бы сделали:

(конд
[(> somevar 50)
(выведите «Эта переменная слишком велика!»)]
[(<somevar 10)
(выведите «Эта переменная слишком мала!»)]
[правда
(выведите "Эта переменная правильна!")])

Вы заметите, что конд отключается между выполнением некоторого оператора и
проверяется условно на истинность или ложность, а затем небольшой код для выполнения, если он превращается
чтобы быть правдой. Вы также заметите, что еще реализуется в конце просто
проверка для правда -- это потому что правда всегда будет правдой, поэтому, если мы зайдем так далеко, мы
всегда запускай это!

Вы могли заметить выше, что если у вас есть такой код:

(если какое-то условие
(тело-если-правда)
(тело-если-ложь))

Но ждать! Что делать, если вы хотите выполнить более одного оператора в теле одного из
эти?

Вы можете сделать следующее:

(если (попробуй что-нибудь)
(из
(выведите «это если правда»)
(печать "а почему бы и нет, давайте продолжим говорить о том, насколько это правда!))
(выведите «это просто ложь»))

Вы можете видеть, что мы использовали do чтобы обернуть несколько операторов. Если вы знакомы с другими
Лиспс, это эквивалент прогноз в другом месте.

Комментарии начинаются с точки с запятой:

(выведите «это будет работать»)
; (выведите «но этого не будет»)
(+ 1 2 3); мы выполним дополнение, а не этот комментарий!

Зацикливание не сложно, но имеет особую структуру. В Python мы могли бы сделать:

для меня в ассортимент(10):
print "'i' теперь на" + str (i)

Эквивалент в Hy будет:

(для [i (диапазон 10)]
(print (+ "'i' теперь на" (str i))))

Вы также можете импортировать и использовать различные библиотеки Python. Например:

(импорт ОС)

(если (os.path.isdir "/ tmp / somedir")
(os.mkdir "/ tmp / somedir / anotherdir")
(выведите «Эй, этого пути нет!»))

Менеджеры контекста Python ( операторы) используются следующим образом:

(с [[f (open "/tmp/data.in")]]
(печать (. читать f)))

что эквивалентно:

с open ("/ tmp / data.in") как f:
печать f.read ()

И да, у нас есть понимание списка! В Python вы можете:

шансы_квадрат = [
pow (число, 2)
для числа в ассортимент(100)
если число% 2 == 1]

В Hy вы могли бы сделать следующее:

(setv коэффициент-квадрат
(список-состав
(номер 2)
(число (диапазон 100))
(= (% число 2) 1)))

; И пример, беззастенчиво украденный со страницы Clojure:
; Перечислим все блоки шахматной доски:

(список-состав
(, ху)
(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')]

Python поддерживает различные причудливые аргументы и аргументы ключевых слов. В Python мы могли бы
видеть:

>>> def optional_arg (pos1, pos2, keyword1 = None, keyword2 = 42):
... вернуть [позиция1, позиция2, ключевое слово1, ключевое слово2]
...
>>> optional_arg (1, 2)
[1, 2, Нет, 42]
>>> optional_arg (1, 2, 3, 4)
[1, 2, 3, 4]
>>> optional_arg (ключевое слово1 = 1, позиция2 = 2, позиция1 = 3, ключевое слово2 = 4)
[3, 2, 1, 4]

То же самое и в Хай:

=> (defn optional-arg [pos1 pos2 & optional keyword1 [keyword2 42]]
... [позиция1 позиция2 ключевое слово1 ключевое слово2])
=> (необязательный аргумент 1 2)
[1 2 Нет 42]
=> (необязательный аргумент 1 2 3 4)
[1 2 3 4]

Если вы используете версию Hy, предшествующую 0.10.1 (например, git master), есть также приятный новый
синтаксис аргумента ключевого слова:

=> (необязательный аргумент: ключевое слово1 1
...: pos2 2
...: pos1 3
...: keyword2 4)
[3, 2, 1, 4]

В противном случае вы всегда можете использовать подать заявление. Но что подать заявление?

Вы знакомы с прохождением * аргументы и ** kwargs в Python ?:

>>> args = [1 2]
>>> kwargs = {"keyword2": 3
... "keyword1": 4}
>>> optional_arg (* аргументы, ** kwargs)

Мы можем воспроизвести это с помощью подать заявление:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "keyword1" 4})
=> (применить optional-arg args kwargs)
[1, 2, 4, 3]

Также существует конструкция аргументов ключевого слова в стиле словаря, которая выглядит так:

(defn другой стиль [& key {"key1" "val1" "key2" "val2"}]
[ключ1 ключ2])

Разница здесь в том, что, поскольку это словарь, вы не можете полагаться на какой-либо конкретный
упорядочивая аргументы.

Hy также поддерживает * аргументы и ** kwargs. В Python:

def some_func (foo, bar, * args, ** kwargs):
импортный отпечаток
pprint.pprint ((foo, bar, args, kwargs))

Эквивалент Hy:

(defn some-func [foo bar & rest args & kwargs kwargs]
(импортный отпечаток)
(pprint.pprint (, foo bar args kwargs)))

Наконец, конечно, нам нужны классы! В Python у нас может быть такой класс:

класс FooBar (объект):
«»»
Еще один пример класса
«»»
def __init __ (self, x):
я.х = х

def get_x (сам):
«»»
Верните нашу копию x
«»»
вернуть self.x

В Hy:

(defclass FooBar [объект]
«Еще один пример класса»
[[--в этом--
(фн [я х]
(setv self.xx)
; В настоящее время требуется для --init--, потому что __init__ не требуется
; Надеюсь, это уйдет :)
Никто)]

[получить-х
(fn [я]
"Верните нашу копию x"
сам.х)]])

Вы также можете использовать атрибуты уровня класса. В Python:

класс Customer (models.Model):
name = models.CharField (max_length = 255)
адрес = models.TextField ()
notes = models.TextField ()

В Hy:

(defclass Клиент [models.Model]
[[имя (models.CharField: max-length 255})]
[адрес (models.TextField)]
[примечания (models.TextField)]])

Hy <-> Питон взаимодействие
Импортируя Hy, вы можете использовать Hy прямо из Python!

Если вы сохраните следующее в привет. почему:

(defn greet [имя] (выведите «привет от хи», имя))

Затем вы можете использовать его непосредственно из python, импортировав hy перед импортом модуля. В
Питон:

импорт хи
импортные приветствия

greetings.greet ("Фу")

Вы также можете объявить функцию в python (или даже класс!) И использовать ее в Hy!

Если вы сохраните следующее в приветствия.py в Python:

def greet (имя):
print ("привет,% s"% (имя))

Вы можете использовать его в Hy:

(импортный привет)
(.greet greetings "foo")

Чтобы использовать аргументы ключевого слова, вы можете использовать в приветствия.py:

def greet (name, title = "Сэр"):
print ("Приветствую,% s% s"% (заголовок, имя))

(импортный привет)
(Привет, привет "Фу")
(Привет, привет "Фу" "Дарт")
(применить (. привет, привет) ["Фу"] {"титул" "Господь"})

Что выведет:

Привет, сэр Фу

Привет, Дарт Фу

Привет, Лорд Фу

Подсказки!
В Hy также есть кое-что, известное как «макрос многопоточности», действительно полезная функция
Clojure's. "Макрос потоковой передачи" (записанный как ->) используется, чтобы избежать глубокого вложения
выражения.

Макрос потоковой передачи вставляет каждое выражение в первый аргумент следующего выражения.
место.

Возьмем классику:

(цикл (печать (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")

Намного читабельнее, не так ли? Используйте макрос threading!

HY СТИЛЬ РУКОВОДСТВО

«Вы знаете, министр, я не согласен с Дамблдором по многим пунктам… но вы не можете отрицать, что он
получил стиль… »- Финеас Найджелус Блэк, Гарри Гончар и домен Оформить заказ of домен Феникс

Руководство по стилю Hy призвано стать набором основных правил для Hyve (да, сообщество Hy
гордится тем, что добавляет Hy ко всему), чтобы написать идиоматический код Hy. Хай многое получает
из Clojure и Common Lisp, всегда сохраняя совместимость с Python.

Вступление
Ассоциация Тао of Hy
Уммон спросил главного монаха: «Какую сутру вы читаете?»
«Нирвана-сутра».
«Нирвана Сутра обладает четырьмя добродетелями, не так ли?»
"Она имеет."
Уммон спросил, беря чашку: «Сколько в ней добродетелей?»
«Вовсе нет», - сказал монах.
«Но древние люди говорили, что это так, не так ли?» - сказал Уммон.
"Что вы думаете о том, что они сказали?"
Уммон ударил по чашке и спросил: «Вы понимаете?»
«Нет, - сказал монах.
«Тогда, - сказал Уммон, - тебе лучше продолжить лекции по сутре».
- макрос (коан)

Ниже приводится краткий список дизайнерских решений, которые повлияли на создание
Hy.

· Похож на Лисп; DTRT с ним (например, тире превращаются в подчеркивание, наушники превращаются в
все заглавные буквы).

· Мы по-прежнему Python. Большинство внутренних компонентов переводят 1: 1 на внутренние компоненты Python.

· Используйте Юникод везде.

· Исправьте неправильные решения в Python 2, когда мы сможем (см. true_division).

· В случае сомнений обращайтесь к Python.

· Если вы все еще не уверены, обратитесь к Clojure.

· Если вы еще более не уверены, обратитесь к Common Lisp.

· Имейте в виду, что мы не Clojure. Мы не Common Lisp. Мы гомоиконный Python, с
лишние биты, которые имеют смысл.

Планировка & вдавливание
· Избегайте конечных пробелов. Они отстой!

· Отступ должен составлять 2 пробела (без жестких табуляций), за исключением случаев, когда он совпадает с отступом
предыдущая строка.

;; Хорошо (и желательно)
(защита выдумки [n]
(если (<= n 2)
n
(+ (фиб (- п 1)) (фиб (- п 2)))))

;; Все еще хорошо
(защита выдумки [n]
(если (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Все еще хорошо
(защита выдумки [n]
(если (<= n 2)
n
(+ (фиб (- п 1)) (фиб (- п 2)))))

;; Истерически смешно
(защита выдумки [n]
(если (<= n 2)
п ;; да, я люблю случайное нажатие клавиши пробела
(+ (фиб (- п 1)) (фиб (- п 2)))))

· Скобки должны никогда оставаться одиноким, грустным и одиноким на своей собственной линии.

;; Хорошо (и желательно)
(защита выдумки [n]
(если (<= n 2)
n
(+ (фиб (- п 1)) (фиб (- п 2)))))

;; Истерически смешно
(защита выдумки [n]
(если (<= n 2)
n
(+ (фиб (- п 1)) (фиб (- п 2)))
)
); ГАХ, СЖИ ЭТО ОГНЕМ

· Выровнять по вертикали позволять блоки.

(пусть [[foo (bar)]
[qux (баз)]]
(фу кекс))

· Встроенные комментарии должны быть через два пробела от конца кода; у них всегда должен быть
пробел между символом комментария и его началом. Кроме того, постарайтесь не
прокомментируйте очевидное.

;; Хорошо
(setv ind (dec x)); индексация начинается с 0

;; Соответствует стилю, но только заявляет очевидное
(setv ind (dec x)); устанавливает индекс на x-1

;; Плохой
(setv ind (dec x)); набор слов для развлечения

Кодирование Стиль
· По традиции старайтесь не использовать защиту для чего-либо, кроме глобальных переменных; использовать сетв
внутренние функции, циклы и т. д.

;; Хорошо (и желательно)
(по умолчанию * предел * 400000)

(defn fibs [ab]
(хотя правда
(выход а)
(setv (, ab) (, b (+ ab)))))

;; Плохо (и нежелательно)
(defn fibs [ab]
(хотя правда
(выход а)
(def (, ab) (, b (+ ab)))))

· Не используйте синтаксис s-выражений там, где предназначен векторный синтаксис. Например, факт
что первый из этих двух примеров работает только потому, что компилятор не слишком
строгий. На самом деле правильный синтаксис в таких местах как этот - последний.

;; Плохо (и зло)
(defn foo (x) (печать x))
(фу 1)

;; Хорошо (и желательно)
(defn foo [x] (печать x))
(фу 1)

· Используйте макрос многопоточности или хвостовой макрос многопоточности при обнаружении глубоко вложенных
s-выражения. Однако будьте осторожны при их использовании. Используйте их, когда ясность и
читаемость улучшается; не создавайте запутанных, трудных для понимания выражений.

;; Предпочтительный
(def * имена *
(с [f (открыть "names.txt")]
(-> (.read f) (.strip) (.replace "\" "" ") (.split", ") (отсортировано))))

;; Не так хорошо, как хотелось бы
(def * имена *
(с [f (открыть "names.txt")]
(отсортировано (.split "," (.replace "\" "" "(.strip (.read f)))))))

;; Наверное, не лучшая идея
(защитный квадрат? [x]
(- >> 2 (pow (int (sqrt x))) (= x)))

· Точечная нотация в стиле Clojure предпочтительнее прямого вызова метода объекта,
хотя и то, и другое будет по-прежнему поддерживаться.

;; Хорошо
(с [fd (open "/ И т.д. / пароль")]
(печать (.readlines fd)))

;; Не так хорошо, как хотелось бы
(с [fd (open "/ И т.д. / пароль")]
(печать (fd.readlines)))

Заключение
«Мода исчезает, стиль вечен» - Ив Сен-Лоран.

Это руководство - всего лишь набор руководящих принципов сообщества, и очевидно, что руководящие принципы сообщества
не имеет смысла без активного сообщества. Взносы приветствуются. Присоединяйтесь к нам на #hy in
freenode, пишите об этом в блоге, твитните и, самое главное, веселитесь с Хай.

Спасибо
· Это руководство во многом основано на @полтаг сообщение в блоге Hy Выживание Гид

· The Clojure Стиль Гид

ДОКУМЕНТАЦИЯ ИНДЕКС

Содержание:

Command линия Интерфейс
hy
Command линия Опции
-c
Выполните код Hy в команду.

$ hy -c "(печать (+ 2 2))"
4

-i
Выполните код Hy в команду, затем оставайтесь в REPL.

-m
Выполните код Hy в модульв том числе определить если определено.

Ассоциация -m флаг завершает список опций, так что все аргументы после модуль имя
передаются модулю в sys.argv.

Новое в версии 0.10.2.

--шпион Перед выполнением распечатайте эквивалентный код Python. Например:

=> (defn salutationsnm [name] (print (+ "Hy" name "!")))
def salutationsnm (имя):
return print (((u'Hy '+ name) + u'! '))
=> (salutationsnm "Ваше имя")
salutationsnm (u'Ваше имя ')
Привет Твое Имя!
=>

Новое в версии 0.9.11.

--show-трассировки
Распечатайте расширенные трассировки для исключений Hy.

Новое в версии 0.9.12.

-v Выведите номер версии Hy и выйдите.

HyC
Command линия Опции
файл[, файлN]
Скомпилируйте код Hy в байт-код Python. Например, сохраните следующий код как
hyname.hy:

(Defn hy-hy [имя]
(print (+ "Хи" имя "!")))

(hy-hy "Афроман")

Затем выполните:

$ hyc hyname.hy
$ python hyname.pyc
Эй, Афроман!

hy2py
Новое в версии 0.10.1.

Command линия Опции
-s

--с-источником
Покажите проанализированную исходную структуру.

-a

--с-аст
Покажите сгенерированный AST.

-нп

--без-питон
Не показывать код Python, сгенерированный из AST.

Hy ( язык)
ПРЕДУПРЕЖДЕНИЕ:
Это неполно; пожалуйста, рассмотрите возможность участия в работе над документацией.

теория of Hy
Хай поддерживает, помимо всего прочего, 100% совместимость в обоих направлениях с Python.
сам. Весь код Hy следует нескольким простым правилам. Запомни это, поскольку оно придет.
удобно.

Эти правила помогают гарантировать, что код Hy идиоматичен и совместим с обоими языками.

· Символы в earmufs будут переведены на версию этой строки с заглавными буквами. За
пример, Foo станет FOO.

· Сущности UTF-8 будут закодированы с использованием Punycode и с префиксом хай_, Например, ⚘
станет hy_w7h, ♥ станет hy_g6hкачества я ♥ ты станет hy_iu_t0x.

· Символы, содержащие тире, будут заменены подчеркиванием. Например,
рендер-шаблон станет render_template. Это означает, что символы с тире будут
затените их эквиваленты подчеркивания, и наоборот.

Встроенный Ins
Hy имеет ряд специальных форм, которые используются для создания правильного Python AST.
Ниже приведены «особые» формы, поведение которых может быть несколько неожиданным в
некоторые ситуации.

.
Новое в версии 0.10.0.

. используется для выполнения атрибутивного доступа к объектам. Он использует небольшой DSL для быстрого
доступ к атрибутам и элементам во вложенной структуре данных.

Например,

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

Компилируется до:

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

. компилирует свой первый аргумент (в примере, Foo) как объект, на котором
разыменование атрибута. Он использует простые символы в качестве атрибутов для доступа (в примере бар,
Баз, Frob) и компилирует содержимое списков (в примере [(+ 1 2)]) для индексации.
Другие аргументы вызывают ошибку компиляции.

Доступ к неизвестным атрибутам вызывает Атрибутеррор. Доступ к неизвестным ключам вызывает
Ошибка индекса (в списках и кортежах) или Ключевая ошибка (по словарям).

->
-> (Или нарезания резьбы макрос) используется, чтобы избежать вложенности выражений. Макрос потоковой передачи
вставляет каждое выражение в место первого аргумента следующего выражения. Следующее
код демонстрирует это:

=> (defn output [ab] (print ab))
=> (-> (+ 4 6) (вывод 5))
10 5

- >>
- >> (Или нарезания резьбы хвост макрос) похож на нарезания резьбы макросно вместо
вставляя каждое выражение в первый аргумент следующего выражения, он добавляет его как
последний аргумент. Следующий код демонстрирует это:

=> (defn output [ab] (print ab))
=> (- >> (+ 4 6) (вывод 5))
5 10

подать заявление
подать заявление используется для применения необязательного списка аргументов и необязательного словаря kwargs
к функции.

Применение: (применять фн-имя [аргументы] [кваргс])

Примеры:

(защита преобразователь []
"привет")

(применить thunk)
; => "ну там"

(defn total-Purchase [цена сумма и необязательные [сборы 1.05] [ндс 1.1]]
(* цена сумма сборы ндс))

(применить total-buy [10 15])
; => 173.25

(применить total-Purchase [10 15] {"НДС" 1.05})
; => 165.375

(применить total-Purchase [] {"цена" 10 "сумма" 15 "ндс" 1.05})
; => 165.375

и
и используется в логических выражениях. Требуется минимум два параметра. Если все параметры
оценить Правда, возвращается последний параметр. В любом другом случае первое ложное значение
будет возвращен. Пример использования:

=> (и Истина Ложь)
Ложь

=> (и True True)
Правда

=> (и Истина 1)
1

=> (и True [] False True)
[]

ПРИМЕЧАНИЕ:
и закорачивает и прекращает оценку параметров, как только первая ложь
встречается.

=> (и False (выведите «привет»))
Ложь

утверждать
утверждать используется для проверки условий во время работы программы. Если условие не
встретил Ассертионеррор Поднялся. утверждать может принимать один или два параметра. Первое
параметр - это условие для проверки, и он должен оцениваться как Правда or Ложь,
второй параметр, необязательный, является меткой для утверждения и строкой, которая будет
поднял с Ассертионеррор. Например:

(assert (= ожидаемое значение переменной))

(утверждать ложно)
; Ассертионеррор

(assert (= 1 2) «один должен быть равен двум»)
; AssertionError: один должен равняться двум

Помощник
Помощник используется для связывания ключа со значением в словаре или для установки индекса списка
к значению. Требуется как минимум три параметра: данным Структура быть измененным, ключ
or индексИ ценностное . Если используется более трех параметров, они будут связаны парами.

Примеры использования:

=> (пусть [[коллекция {}]]
... (доц. сборник "Собака" "Лай")
... (сборник печати))
{u'Dog ': u'Bark'}

=> (пусть [[коллекция {}]]
... (доц. сборник "Собака" "Лай" "Кот" "Мяу")
... (сборник печати))
{u'Cat ': u'Meow', u'Dog ': u'Bark'}

=> (пусть [[сборник [1 2 3 4]]]
... (ассоциированная коллекция 2 Нет)
... (сборник печати))
[1, 2, Нет, 4]

ПРИМЕЧАНИЕ:
Помощник изменяет структуру данных на месте и возвращает Ничто.

перерыв
перерыв используется для выхода из петли. Он немедленно завершает цикл. Следующее
пример имеет бесконечный в то время как цикл, который завершается, как только пользователь входит k.

(в то время как True (if (= "k" (raw-input "?"))
(ломать)
(распечатайте «Попробуй еще раз»)))

конд
конд можно использовать для построения вложенных if заявления. В следующем примере показан
связь между макросом и его расширением:

(усл [условие-1 результат-1]
[условие-2 результат-2])

(если условие-1 результат-1
(если условие-2 результат-2))

Как показано ниже, выполняется только первый соответствующий блок результатов.

=> (defn check-value [значение]
... (cond [(<значение 5) (выведите «значение меньше 5»)]
... [(= значение 5) (выведите «значение равно 5»)]
... [(> значение 5) (выведите «значение больше 5»)]
... [True (print "значение - это то, чего не должно быть")]))

=> (контрольное значение 6)
значение больше 5

продолжать
продолжать возвращает выполнение в начало цикла. В следующем примере
(побочный эффект1) вызывается для каждой итерации. (побочный эффект2), однако, требуется только
любое другое значение в списке.

;; предполагая, что (побочный эффект1) и (побочный эффект2) являются функциями и
;; коллекция представляет собой список числовых значений

(для [x коллекции]
(из
(побочный эффект1 x)
(если (% x 2)
(Продолжать))
(побочный эффект2 х)))

диктофон
диктофон используется для создания словарей. Требуется три-четыре параметра. Первое
два параметра предназначены для управления возвращаемым значением (пара ключ-значение), а третий -
используется для выбора элементов из последовательности. Четвертый и необязательный параметр можно использовать для
отфильтровать некоторые элементы в последовательности на основе условного выражения.

=> (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 (диапазон 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do может принимать любое количество аргументов от 1 до n.

защиту / сетв
защиту и сетв используются для привязки значения, объекта или функции к символу. Например:

=> (def names ["Алиса" "Боб" "Чарли"])
=> (напечатать имена)
[u'Alice ', u'Bob', u'Charlie ']

=> (setv counter (fn [элемент коллекции] (элемент коллекции .count)))
=> (counter [1 2 3 4 5 2 3] 2)
2

DEFCLASS
Новые классы объявляются с помощью DEFCLASS. Может принимать два необязательных параметра: вектор
определение возможных суперклассов и другого вектора, содержащего атрибуты нового
как два вектора элементов.

(defclass имя-класса [суперкласс-1 суперкласс-2]
[[значение атрибута]])

И значения, и функции могут быть связаны с новым классом, как показано в примере ниже:

=> (defclass Cat []
... [[возраст Нет]
... [цвет "белый"]
... [говорите (fn [self] (печатайте «Мяу»))]])

=> (точка определения (Кошка))
=> (setv spot.colour "Черный")
'Чернить'
=> (.speak spot)
мяу

определение / DEFUN
определение и DEFUN макросы используются для определения функций. Они принимают три параметра: имя
определяемой функции, вектор параметры, и тело функции:

(имя определения [параметры] тело)

Перед параметрами могут быть следующие ключевые слова:

&по желанию
Параметр необязательный. Параметр может быть представлен в виде списка из двух пунктов, где
первый элемент - это имя параметра, а второй - значение по умолчанию. Параметр
также может быть задан как отдельный элемент, и в этом случае значение по умолчанию Ничто.

=> (defn total-value [value & optional [налог на добавленную стоимость 10]]
... (+ (/ (* налог на добавленную стоимость) 100) стоимость))

=> (общее значение 100)
110.0

=> (общее значение 100 1)
101.0

&ключ

& kwargs
Параметр будет содержать 0 или более аргументов ключевого слова.

В следующих примерах кода определяется функция, которая будет печатать все ключевые слова.
аргументы и их значения.

=> (defn параметры печати [& kwargs kwargs]
... (для [(, kv) (.items kwargs)] (print kv)))

=> (применить параметры печати [] {"параметр-1" 1 "параметр-2" 2})
параметр-2 2
параметр-1 1

&отдых Параметр будет содержать 0 или более позиционных аргументов. Никаких других позиционных
аргументы могут быть указаны после этого.

В следующем примере кода определяется функция, которой можно присвоить числовые значения от 0 до n.
параметры. Затем он суммирует каждое нечетное число и вычитает каждое четное число.

=> (defn zig-zag-sum [& остальные числа]
(пусть [[нечетные числа (список-состав x [числа x] (нечетные? x))]
[четные числа (список-состав x [x числа] (даже? x))]]
(- (сумма нечетных чисел) (сумма четных чисел))))

=> (зигзагообразная сумма)
0
=> (зигзагообразная сумма 3 9 4)
8
=> (зигзагообразная сумма 1 2 3 4 5 6)
-3

defn-псевдоним / defun-псевдоним
Новое в версии 0.10.0.

Ассоциация defn-псевдоним и defun-псевдоним макросы очень похожи на определениес тем отличием, что
вместо определения функции с одним именем они также могут определять псевдонимы. Другой
чем взять список символов для имен функций в качестве первого параметра, defn-псевдоним и
defun-псевдоним не отличаются от определение и DEFUN.

=> (defn-alias [псевдоним основного имени] []
... (выведите «Здравствуйте!»))
=> (основное имя)
"Привет!"
=> (псевдоним)
"Привет!"

определить
Новое в версии 0.10.1.

Ассоциация определить макрос определяет основную функцию, которая немедленно вызывается с помощью sys.argv as
аргументы тогда и только тогда, когда этот файл выполняется как сценарий. Другими словами, это:

(defmain [& rest args]
(делать что-то с аргументами))

эквивалент:

def main (* args):
do_something_with (аргументы)
вернуть 0

если __name__ == "__main__":
импорт системы
retval = main (* sys.arg)

если isinstance (retval, int):
sys.exit (retval)

Обратите внимание, что, как вы можете видеть выше, если вы вернете целое число из этой функции, это будет
используется как статус выхода для вашего скрипта. (Python по умолчанию выходит из статуса 0, в противном случае
а значит, все в порядке!)

(Поскольку (sys.exit 0) не запускается явно в случае нецелочисленного возврата из
определить, неплохо было бы поставить (по умолчанию) как последний фрагмент кода в вашем файле.)

дефмакро
дефмакро используется для определения макросов. Общий формат (дефмакро имя [параметры]
выражение).

В следующем примере определяется макрос, который можно использовать для изменения порядка элементов в коде.
позволяя пользователю писать код в инфиксной нотации, где оператор находится между
операнды.

=> (инфикс defmacro [код]
... (квазицитат (
... (отменить цитату (получить код 1))
... (отменить цитату (получить код 0))
... (unquote (получить код 2)))))

=> (инфикс (1 + 1))
2

defmacro-псевдоним
defmacro-псевдоним используется для определения макросов с несколькими именами (псевдонимами). Общий формат
is (defmacro-псевдоним [имена] [параметры] выражение). Он создает несколько макросов с одним и тем же
список параметров и тело в соответствии с указанным списком имен.

В следующем примере определяются два макроса, каждый из которых позволяет пользователю писать код на
инфиксная запись.

=> (defmacro-alias [infix infi] [код]
... (квазицитат (
... (отменить цитату (получить код 1))
... (отменить цитату (получить код 0))
... (unquote (получить код 2)))))

=> (инфикс (1 + 1))
2
=> (infi (1 + 1))
2

defmacro / g!
Новое в версии 0.9.12.

defmacro / g! это специальная версия дефмакро который используется для автоматического создания генсим
для любого символа, который начинается с g!.

Например, г! а станет (генсим "а").

СМ ТАКЖЕ:
Раздел using-gensym

защитник
Новое в версии 0.9.12.

защитник определяет макрос чтения, позволяющий реструктурировать или изменить синтаксис.

=> (defreader ^ [expr] (print expr))
=> # ^ (1 2 3 4)
(1 2 3 4)
=> # ^ "Привет"
"Привет"

СМ ТАКЖЕ:
Макросы чтения разделов

из
Новое в версии 0.9.12.

из удаляет объект из текущего пространства имен.

=> (setv foo 42)
=> (дель фу)
=> foo
Traceback (последний последний вызов):
Файл " ", строка 1, в
NameError: имя 'foo' не определено

из также может удалять объекты из сопоставлений, списков и т. д.

=> (setv test (список (диапазон 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" "bar"})
=> dic
{"foo": "bar"}
=> (del (получить dic "foo"))
=> dic
{}

дото
Новое в версии 0.10.1.

дото используется для упрощения последовательности вызовов методов объекта.

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

=> (коллекция setv [])
=> (.append коллекция 1)
=> (.append коллекция 2)
=> (обратный сбор)
=> коллекция
[2 1]

Eval
Eval оценивает выражение в кавычках и возвращает значение.

=> (eval '(вывести «Hello World»))
"Привет, мир"

оценка и компиляция
оценка при компиляции
первый / автомобиль
первый и автомобиль макросы для доступа к первому элементу коллекции:

=> (первый (диапазон 10))
0

для
для используется для вызова функции для каждого элемента в списке или векторе. Результаты каждого
звонок отклоняется, и для выражение возвращает Ничто вместо. В примере кода повторяется
за лыжных шлемов и для каждого элемент in лыжных шлемов называет побочный эффект функция с
элемент в качестве аргумента:

;; предполагая, что (побочный эффект) - это функция, которая принимает единственный параметр
(для [коллекция элементов] (элемент побочного эффекта))

;; for может иметь дополнительный блок else
(для [коллекция элементов] (элемент побочного эффекта)
(иначе (побочный эффект-2)))

Необязательный еще блок выполняется только в том случае, если для цикл завершается нормально. Если
исполнение остановлено с перерыв, еще блок не выполняется.

=> (для [элемент [1 2 3]] (если (<элемент 3)
... (элемент печати)
... (ломать))
... (else (выведите «цикл завершен»)))
1
2

=> (для [элемент [1 2 3]] (если (<элемент 4)
... (элемент печати)
... (ломать))
... (else (выведите «цикл завершен»)))
1
2
3
петля закончена

генэкспр
генэкспр используется для создания выражений генератора. Требуется два-три параметра. В
первый параметр - это выражение, управляющее возвращаемым значением, а второй используется
для выбора элементов из списка. Третий и необязательный параметр можно использовать для фильтрации
некоторые элементы в списке основаны на условном выражении. генэкспр аналогично
список-состав, за исключением того, что он возвращает итерацию, которая оценивает значения одно за другим вместо
немедленно оценивая их.

=> (коллекция def (диапазон 10))
=> (по умолчанию отфильтровано (genexpr x [коллекция x] (даже? x)))
=> (список отфильтрован)
[0, 2, 4, 6, 8]

генсим
Новое в версии 0.9.12.

генсим используется для создания уникального символа, который позволяет писать макросы без
случайное совпадение имен переменных.

=> (генсим)
u ': G_1235'

=> (родственный "х")
u ': x_1236'

СМ ТАКЖЕ:
Раздел using-gensym

получить
получить используется для доступа к отдельным элементам в списках и словарях. получить принимает два параметра:
домен данным Структура и индекс or ключ пункта. Затем он вернет соответствующий
значение из словаря или списка. Пример использования:

=> (пусть [[животные {"собака" "лай" "кошка" "мяу"}]
... [числа ["ноль" "один" "два" "три"]]]
... (распечатать (получить животных "собака"))
... (распечатать (получить числа 2)))
кора
два

ПРИМЕЧАНИЕ:
получить вызывает KeyError, если в словаре запрашивается несуществующий ключ.

ПРИМЕЧАНИЕ:
получить вызывает IndexError, если в списке или кортеже запрашивается индекс, который находится вне
границы.

Глобальный
Глобальный может использоваться для обозначения символа как глобального. Это позволяет программисту назначить
значение в глобальный символ. Для чтения глобального символа не требуется Глобальный ключевое слово -
только назначение.

В следующем примере показано, как глобальный символ a присваивается значение в функции и
позже печатается в другой функции. Без Глобальный ключевое слово, вторая функция
бросил бы ИмяОррор.

(defn set-a [значение]
(глобальный а)
(установить значение))

(определить print-a []
(печать а))

(комплект-5)
(печать-а)

if / если не
Новое в версии 0.10.0: if-not

if используется для условного выбора кода для выполнения. Он должен содержать условие
блок и блок, который должен быть выполнен, если блок условия оценивается как Правда. Необязательно,
он может содержать последний блок, который выполняется в случае, если оценка условия
Ложь.

если не аналогично, но второй блок будет выполнен, когда условие не выполняется, пока
третий и последний блок выполняется, когда тест успешен - обратный порядок if.

Пример использования:

(если (на счету остались деньги)
(распечатайте «пошли по магазинам»)
(выведите «поехали работать»))

(если-нет (деньги-остались? счет)
(выведите «поехали работать»)
(распечатайте «пошли по магазинам»))

Правдивость Python уважается. Ничто, Ложь, ноль любого числового типа, пустая последовательность,
и пустой словарь считаются Ложь; все остальное считается Правда.

шепелявить-если / лифт и шепелявить если нет / Лиф-не
Новое в версии 0.10.0.

Новое в версии 0.10.2: lisp-if-not / lif-not

Для тех, кто предпочитает больше Lispy if пункт, у нас есть шепелявить-еслиили лифт. Это только считает
Ничто / ноль быть ложным! Все остальные "ложные" значения Python считаются истинными.
Наоборот, имеем шепелявить если нет и Лиф-не параллельно с if и если не который меняет
сравнение.

=> (lisp-if True "true" "false")
"True"
=> (lisp-if False "true" "false")
"True"
=> (lisp-if 0 «истина» «ложь»)
"True"
=> (lisp-if nil "true" "false")
"ложный"
=> (lisp-if None "true" "false")
"ложный"
=> (lisp-if-not nil "истина" "ложь")
"True"
=> (lisp-if-not None "true" "false")
"True"
=> (lisp-if-not False "true" "false")
"ложный"

; Эквивалентно, но короче
=> (lif True "true" "false")
"True"
=> (lif nil "истина" "ложь")
"ложный"
=> (lif-not None "true" "false")
"True"

Импортировать
Импортировать используется для импорта модулей, как в Python. Есть несколько способов Импортировать может
использоваться.

;; Импортирует каждый из этих модулей
;;
;; Питон:
;; импорт системы
;; импорт os.path
(импорт sys os.path)

;; Импорт из модуля
;;
;; Python: существует импорт из os.path, isdir, isfile
(импорт [os.path [существует isdir isfile]])

;; Импорт с псевдонимом
;;
;; Python: импортировать sys как systest
(импорт [sys: as systest])

;; Вы можете перечислить сколько угодно импортов разных типов.
(импорт [tests.resources [функция kwtest с тире]]
[os.path [существует isdir isfile]]
[sys: as systest])

;; Импортировать все функции модуля в текущее пространство имен
(импорт [sys [*]])

лямбда / fn
лямбда и fn может использоваться для определения анонимной функции. Параметры аналогичны
определение: первый параметр - это вектор параметров, а остальные - это тело
функции. лямбда возвращает новую функцию. В следующем примере анонимная функция
определяется и передается другой функции для фильтрации вывода.

=> (по определению людей [{: name "Alice": age 20}
... {: name "Bob": возраст 25}
... {: name "Charlie": 50 лет}
... {: name "Dave": 5 лет}])

=> (defn display-people [фильтр людей]
... (для [человек люди] (if (отфильтровать человека) (print (: имя человека)))))

=> (display-people people (fn [person] (<(: age person) 25)))
Алиса
Дейв

Как и в обычных определениях функций, если первый элемент тела является строкой, он
служит строкой документации. Это полезно для предоставления строк документации для методов класса.

=> (setv раз-три
... (фн [х]
... «Умножает введенные данные на три и возвращает результат».
... (* х 3)))

Это можно подтвердить с помощью встроенного в Python помощь функция:

=> (помощь раз-три)
Справка по функции times_three:

times_three (x)
Умножает ввод на три и возвращает результат
(КОНЕЦ)

последний
Новое в версии 0.10.2.

последний может использоваться для доступа к последнему элементу коллекции:

=> (последняя [2 4 6])
6

позволять
позволять используется для создания переменных с лексической областью видимости. Они созданы в начале
позволять форма и перестают существовать после формы. Следующий пример демонстрирует это
поведение:

=> (let [[x 5]] (выведите x)
... (let [[x 6]] (выведите x))
... (выведите x))
5
6
5

Ассоциация позволять макрос принимает два параметра: вектор, определяющий переменные и тело который получает
казнены. переменные вектор, каждый элемент которого является либо одной переменной, либо вектором
определение пары значений переменной. В случае одной переменной ей присваивается значение
Ничто; в противном случае используется указанное значение.

=> (let [x [y 5]] (выведите xy))
Нет 5

список-состав
список-состав выполняет составление списка. Требуется два-три параметра. Первое
параметр - это выражение, управляющее возвращаемым значением, а второе используется для
выберите элементы из списка. Третий и необязательный параметр можно использовать для фильтрации некоторых
элементов в списке на основе условного выражения. Некоторые примеры:

=> (коллекция def (диапазон 10))
=> (список-состав x [коллекция x])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (список-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 используется в логических выражениях. Требуется минимум два параметра. Он вернет
первый не ложный параметр. Если такого значения не существует, будет возвращен последний параметр.

=> (или Истина Ложь)
Правда

=> (и Ложь Ложь)
Ложь

=> (и Ложь 1 Истина Ложь)
1

ПРИМЕЧАНИЕ:
or закорачивает и прекращает оценку параметров, как только первое истинное значение
встречается.

=> (или True (выведите «привет»))
Правда

Распечатать
Распечатать используется для вывода на экран. Пример использования:

(напечатайте «Привет, мир!»)

ПРИМЕЧАНИЕ:
Распечатать всегда возвращается Ничто.

квазицитат
квазицитат позволяет цитировать форму, а также выборочно оценивать выражения.
Выражения внутри квазицитат можно выборочно оценивать с помощью закрывать кавычки (~).
оцененная форма также может быть склеена с помощью без кавычек (~@). Квазицитат может быть также
написано с использованием обратной кавычки (`) символ.

;; пусть qux будет переменной со значением (bar baz)
`(foo ~ qux)
; эквивалентно '(foo (bar baz))
`(foo ~ @ qux)
; эквивалентно '(foo bar baz)

цену
цену возвращает переданную ему форму без ее оценки. цену альтернативно может быть
написано с использованием апострофа (') символ.

=> (setv x '(print «Hello World»))
; переменная x установлена ​​в выражение и не оценивается
=> х
(u'print 'u'Hello World')
=> (eval x)
Привет мир

требовать
требовать используется для импорта макросов из заданного модуля. Требуется хотя бы один параметр
указание модуля, макросы которого следует импортировать. Можно импортировать несколько модулей
с одним требовать.

В следующем примере будут импортированы макросы из модуль-1 и модуль-2:

(требуется модуль-1 модуль-2)

отдых / корд
отдых и корд вернуть коллекцию, переданную в качестве аргумента, без первого элемента:

=> (отдых (диапазон 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

набор-комп
набор-комп используется для создания наборов. Требуется два-три параметра. Первый параметр
для управления возвращаемым значением, а второй используется для выбора элементов из
последовательность. Третий и необязательный параметр можно использовать для фильтрации некоторых элементов в
последовательность, основанная на условном выражении.

=> (установить данные [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x данные] (нечетное? x))
{1, 3, 5}

кусочек
кусочек может использоваться, чтобы взять подмножество списка и создать из него новый список. Форма
принимает по крайней мере один параметр, определяющий список для нарезки. Два необязательных параметра могут быть
используется для указания начальной и конечной позиции подмножества. Если они не поставляются,
значение по умолчанию Ничто будет использоваться вместо этого. Третий необязательный параметр используется для
контрольный шаг между элементами.

кусочек следует тем же правилам, что и его аналог Python. Подсчитываются отрицательные показатели
начиная с конца списка. Некоторые примеры использования:

=> (коллекция def (диапазон 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

(throw (IOError "foobar"))
; Вывести ошибку IOError ("foobar")

бросать может принимать один аргумент ( Исключение класс или экземпляр) или нет аргументов для
поднять последний Исключение.

стараться
Ассоциация стараться форма используется для начала стараться / поймать блокировать. Форма используется следующим образом:

(пытаться
(функция, подверженная ошибкам)
(catch [e ZeroDivisionError] (выведите «Деление на ноль»))
(иначе (выведите «без ошибок»))
(наконец (выведите «все готово»)))

стараться должен содержать хотя бы один поймать блок, и может необязательно включать еще or в конце концов
блокировать. Если возникает ошибка с совпадающим блоком перехвата во время выполнения
склонная к ошибкам функция, Что поймать блок будет выполнен. Если ошибок не возникает, еще
блок выполнен. В в конце концов блок будет выполняться последним независимо от того,
возникла ошибка.

если не
Ассоциация если не макрос - это сокращение для написания if заявление, которое проверяет, если данный
условно Ложь. Ниже показано расширение этого макроса.

(кроме условного оператора)

(если условный
Ничто
(сделать заявление))

закрывать кавычки
В квазиквотированной форме закрывать кавычки принудительно оценивает символ. закрывать кавычки псевдоним
тильда (~) символ.

(по умолчанию "Cuddles")
(квазицитат (= имя (имя без кавычек)))
; => (u '=' u'name 'u'Cuddles')

`(= имя ~ имя)
; => (u '=' u'name 'u'Cuddles')

без кавычек
без кавычек принудительно выполняет оценку символа в квазиквотируемой форме, как и
закрывать кавычки. без кавычек может использоваться только в том случае, если символ, не заключенный в кавычки, содержит
итеративное значение, поскольку оно «соединяет» повторяемое значение с квазиквотируемой формой. без кавычек is
псевдоним ~@ символ.

(по умолчанию [1 2 3 4])
(квазицитат (+ (числа без кавычек)))
; => (u '+' 1L 2L 3L 4L)

`(+ ~ @ число)
; => (u '+' 1L 2L 3L 4L)

когда
когда аналогично если не, за исключением того, что он проверяет, когда данное условие Правда, Не то
возможно иметь еще блок в когда макрос. Ниже показано расширение
макро.

(при условном утверждении)

(если условно (оператор do))

в то время как
в то время как используется для выполнения одного или нескольких блоков, пока выполняется условие. Следующее
Пример выведет "Hello world!" на экран бесконечно:

(при этом True (выведите «Hello world!»))


используется для обертывания выполнения блока в диспетчере контекста. Контекст
Затем менеджер может настроить локальную систему и отключить ее контролируемым образом. В
архетипический пример использования это при обработке файлов. может связать контекст с
аргумент или полностью игнорируйте его, как показано ниже:

(с блоком [[arg (expr)]])

(с блоком [[(expr)]])

(с блоком [[arg (expr)] [(expr)]]]

В следующем примере откроется НОВОСТИ файл и распечатать его содержимое на экране. В
файл автоматически закрывается после обработки.

(с [[f (открыть «НОВОСТИ»)]] (напечатать (. прочитать f)))

с декоратором
с декоратором используется для обертывания функции другим. Функция, выполняющая
украшение должно принимать единственное значение: декорируемую функцию и возвращать новое
функции. с декоратором принимает минимум два параметра: функция, выполняющая
украшение и украшаемая функция. Можно использовать более одной функции-декоратора.
применяемый; они будут применяться в порядке от внешнего к внутреннему, т.е. первое
декоратор будет самым внешним и так далее. Декораторы с аргументами называются просто
как вызов функции.

(с-декоратором-декоратором-забавой
(определение-функция [] ...)

(с-декоратором decorator1 decorator2 ...
(определение-функция [] ...)

(с-декоратором (аргумент декоратора) ..
(определение-функция [] ...)

В следующем примере inc-декоратор используется для украшения функции дополнение с
функция, которая принимает два параметра и вызывает декорированную функцию со значениями, которые
увеличивается на 1. Когда декорированный дополнение вызывается со значениями 1 и 1, конец
результат будет 4 (1 + 1 + 1 + 1).

=> (defn inc-декоратор [функция]
... (fn [значение-1 значение-2] (func (+ значение-1 1) (+ значение-2 1))))
=> (defn inc2-декоратор [функция]
... (fn [значение-1 значение-2] (func (+ значение-1 2) (+ значение-2 2))))

=> (with-decorator inc-decorator (defn сложение [ab] (+ ab)))
=> (сложение 1 1)
4
=> (с-декоратором inc2-декоратором inc-декоратором
... (определение сложения [ab] (+ ab)))
=> (сложение 1 1)
8

с-gensyms
Новое в версии 0.9.12.

с-генсим используется для создания набора генсим для использования в макросе. Следующий код:

(with-gensyms [abc]
...)

расширяется до:

(пусть [[a (gensym)
[b (генсим)
[с (генсим)]]
...)

СМ ТАКЖЕ:
Раздел using-gensym

Уступать
Уступать используется для создания объекта-генератора, который возвращает одно или несколько значений. Генератор
является итеративным и поэтому может использоваться в циклах, списках и других подобных
конструкты.

Функция случайные числа показывает, как генераторы могут быть использованы для генерации бесконечных серий
без использования бесконечного количества памяти.

=> (defn multiply [базовые коэффициенты]
... (для [[(, базовый коэффициент) (базовые коэффициенты почтового индекса)]]
... (доходность (* базовый коэффициент))))

=> (умножить (диапазон 5) (диапазон 5))


=> (список-comp значение [значение (умножить (диапазон 10) (диапазон 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (импорт случайный)
=> (defn random-numbers [low high]
... (в то время как True (выход (.randint случайный низкий высокий))))
=> (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 Основные
Основные функции
Butlast
Применение: (но последний колл)

Возвращает итератор всех элементов, кроме последнего в Coll.

=> (список (бутласт (диапазон 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (список (butlast [1]))
[]

=> (список (butlast []))
[]

=> (импортировать itertools)
=> (list (взять 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

колл?
Новое в версии 0.10.0.

Применение: (колл? x)

Returns Правда if x повторяется, а не является строкой.

=> (coll? [1 2 3 4])
Правда

=> (coll? {"a" 1 "b" 2})
Правда

=> (coll? "abc")
Ложь

минусы
Новое в версии 0.10.0.

Применение: (минусы a b)

Возвращает свежую минусовку с автомобилем a и cdr b.

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

=> (= 'hd (автомобиль а))
Правда

=> (= 'tl (cdr a))
Правда

минусы?
Новое в версии 0.10.0.

Применение: (минусы? фу)

Проверяет, есть ли Foo это cons-ячейка.

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

=> (минусы? а)
Правда

=> (минусы? ноль)
Ложь

=> (минусы? [1 2 3])
Ложь

декабрь
Применение: (декабрь x)

Возвращает на единицу меньше, чем x. Эквивалентно (- x 1). Поднимает TypeError if (Вы не (числовой? Икс)).

=> (3 уб.)
2

=> (0 уб.)
-1

=> (12.3 уб.)
11.3

демонтировать
Новое в версии 0.10.0.

Применение: (разобрать дерево &по желанию [кодогенерация ложный])

Выгрузить Python AST для данного Hy дерево на стандартный вывод. Если кодогенератор is Правда, функция
вместо этого печатает код Python.

=> (разобрать '(вывести «Hello World!»))
Модуль (
body = [
Expr (value = Call (func = Name (id = 'print'), args = [Str (s = 'Hello World!')], Keywords = [], starargs = None, kwargs = None))])

=> (дизассемблировать '(вывести "Hello World!") true)
print ('Привет, мир!')

пустой?
Применение: (пустой? колл)

Returns Правда if Coll пусто. Эквивалентно (= 0 (лен кол)).

=> (пусто? [])
Правда

=> (пусто? "")
Правда

=> (пусто? (, 1 2))
Ложь

каждый?
Новое в версии 0.10.0.

Применение: (каждый? PRED колл)

Returns Правда if (пред x) логично верно для каждого x in CollВ противном случае Ложь, Вернуть Правда
if Coll пусто.

=> (каждый? даже? [2 4 6])
Правда

=> (каждый? даже? [1 3 5])
Ложь

=> (каждый? даже? [2 4 5])
Ложь

=> (каждый? даже? [])
Правда

плавать?
Применение: (плавать? x)

Returns Правда if x это поплавок.

=> (с плавающей точкой? 3.2)
Правда

=> (с плавающей запятой? -2)
Ложь

четный?
Применение: (четное? x)

Returns Правда if x даже. Поднимает TypeError if (Вы не (числовой? Икс)).

=> (даже? 2)
Правда

=> (даже? 13)
Ложь

=> (даже? 0)
Правда

личность
Применение: (личность x)

Возвращает аргумент, предоставленный функции.

=> (тождество 4)
4

=> (список (идентификатор карты [1 2 3 4]))
[1 2 3 4]

вкл
Применение: (включая x)

Возвращает на один больше, чем x. Эквивалентно (+ x 1). Поднимает TypeError if (Вы не (числовой? Икс)).

=> (прибавка 3)
4

=> (прибавка 0)
1

=> (прибавка 12.3)
13.3

пример?
Применение: (пример? класс x)

Returns Правда if x является примером класс.

=> (экземпляр? float 1.0)
Правда

=> (экземпляр? int 7)
Правда

=> (экземпляр? str (str "foo"))
Правда

=> (defclass TestClass [объект])
=> (setv inst (TestClass))
=> (экземпляр? TestClass inst)
Правда

целое число?
Применение: (целое число? x)

Returns Правда if x целое число. Для Python 2 это либо Int or длинной. Для Python 3
это Int.

=> (целое число? 3)
Правда

=> (целое число? -2.4)
Ложь

перемежать
Новое в версии 0.10.1.

Применение: (чередовать последовательность 1 последовательность 2 ...)

Возвращает итерацию первого элемента в каждой из последовательностей, затем второго и т. Д.

=> (список (чередование (диапазон 5) (диапазон 100)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (список (чередование (диапазон 1000000) «abc»))
[0, 'a', 1, 'b', 2, 'c']

вставлять
Новое в версии 0.10.1.

Применение: (вставьте пункт послед.)

Возвращает итерацию элементов последовательности, разделенных элементом.

=> (список (вставить "!" "abcd"))
['a', '!', 'b', '!', 'c', '!', 'd']

=> (список (вставить -1 (диапазон 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

повторяемый?
Применение: (повторяемый? x)

Returns Правда if x повторяется. Итерируемые объекты возвращают новый итератор, когда (итер x) is
называется. Контраст с итератор?.

=> ;; работает для струнных
=> (итерируемый? (str "abcde"))
Правда

=> ;; работает для списков
=> (итерируемый? [1 2 3 4 5])
Правда

=> ;; работает для кортежей
=> (итерируемый? (, 1 2 3))
Правда

=> ;; работает для dicts
=> (итерируемый? {: a 1: b 2: c 3})
Правда

=> ;; работает для итераторов / генераторов
=> (итерация? (повторить 3))
Правда

итератор?
Применение: (итератор? x)

Returns Правда if x это итератор. Итераторы - это объекты, которые возвращаются как
итератор, когда (итер x) называется. Контраст с повторяемый?.

=> ;; не работает для списка
=> (итератор? [1 2 3 4 5])
Ложь

=> ;; но мы можем получить его из списка
=> (итератор? (iter [1 2 3 4 5]))
Правда

=> ;; не работает на диктофон
=> (итератор? {: a 1: b 2: c 3})
Ложь

=> ;; создать итератор из dict
=> (итератор? (iter {: a 1: b 2: c 3}))
Правда

список*
Применение: (список* &отдых хвостик)

Создает цепочку вложенных cons-ячеек (точечный список), содержащую аргументы. Если
В списке аргументов есть только один элемент, верните его.

=> (список * 1 2 3 4)
(1 2 3)

=> (список * 1 2 3 [4])
[1, 2, 3, 4]

=> (список * 1)
1

=> (минусы? (список * 1 2 3 4))
Правда

макрорасширение
Новое в версии 0.10.0.

Применение: (макроразвернуть форма)

Возвращает полное раскрытие макроса форма.

=> (macroexpand '(-> (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')

MACROEXPAND-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)

Returns Правда if x меньше нуля. Поднимает TypeError if (Вы не (числовой? Икс)).

=> (нег? -2)
Правда

=> (нег? 3)
Ложь

=> (нег? 0)
Ложь

ноль?
Применение: (ноль? x)

Returns Правда if x is ноль / Ничто.

=> (ноль? ноль)
Правда

=> (ноль? Нет)
Правда

=> (ноль? 0)
Ложь

=> (setf x nil)
=> (ноль? x)
Правда

=> ;; list.append всегда возвращает None
=> (ноль? (.append [1 2 3] 4))
Правда

никто?
Применение: (никто? x)

Returns Правда if x is Ничто.

=> (нет? Нет)
Правда

=> (нет? 0)
Ложь

=> (setf x Нет)
=> (нет? x)
Правда

=> ;; list.append всегда возвращает None
=> (нет? (.append [1 2 3] 4))
Правда

энный
Применение: (энный Coll n &по желанию [дефолт ноль])

Возвращает n-й элемент в коллекции, считая от 0. Возвращает значение по умолчанию, ноль, Если
вне пределов (если не указано иное). Поднимает ValueError 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)
Traceback (последний последний вызов):
...
ValueError: Индексы для islice () должны иметь значение None или целое число: 0 <= x <= sys.maxsize.

числовой?
Применение: (числовой? x)

Returns Правда if x является числовым, как определено в Python числа. класса.

=> (числовой? -2)
Правда

=> (числовой? 3.2)
Правда

=> (числовой? "foo")
Ложь

странный?
Применение: (странный? x)

Returns Правда if x странно. Поднимает TypeError if (Вы не (числовой? Икс)).

=> (нечетное? 13)
Правда

=> (нечетное? 2)
Ложь

=> (нечетное? 0)
Ложь

поз?
Применение: (поз? x)

Returns Правда if x больше нуля. Поднимает TypeError if (Вы не (числовой? Икс)).

=> (поз? 3)
Правда

=> (поз? -2)
Ложь

=> (поз? 0)
Ложь

второй
Применение: (второй колл)

Возвращает второй член Coll. Эквивалентно (получать Coll 1).

=> (второй [0 1 2])
1

некоторые
Новое в версии 0.10.0.

Применение: (несколько PRED колл)

Возвращает первое логически истинное значение (пред x) для любого x in CollВ противном случае ноль.
ВОЗВРАТ ноль if Coll пусто.

=> (некоторые даже? [2 4 6])
Правда

=> (ноль? (некоторые даже? [1 3 5]))
Правда

=> (ноль? (некоторая идентичность [0 "" []]))
Правда

=> (некоторая идентичность [0 "непустая-строка" []])
'непустая строка'

=> (ноль? (некоторые даже? []))
Правда

строка?
Применение: (нить? x)

Returns Правда if x это строка.

=> (строка? "foo")
Правда

=> (строка? -2)
Ложь

символ?
Применение: (символ? x)

Returns Правда if x это символ.

=> (символ? 'foo)
Правда

=> (символ? '[abc])
Ложь

нуль?
Применение: (нуль? x)

Returns Правда if x это ноль.

=> (ноль? 3)
Ложь

=> (ноль? -2)
Ложь

=> (ноль? 0)
Правда

Последовательность функции
Функции последовательности могут создавать потенциально бесконечную последовательность или работать с ней без
требуя, чтобы последовательность была полностью реализована в списке или подобном контейнере. Они делают это
возвращает итератор Python.

Мы можем использовать канонический генератор бесконечных чисел Фибоначчи в качестве примера того, как использовать
некоторые из этих функций.

(защита выдумки []
(установить 0)
(настройка b 1)
(хотя правда
(выход а)
(setv (, ab) (, b (+ ab)))))

Обратите внимание (в то время как правда ...) петля. Если мы запустим это в REPL,

=> (фиб)


Вызов функции возвращает только итератор, но не работает, пока мы его не используем.
Пробовать что-то подобное не рекомендуется, так как бесконечный цикл будет работать до тех пор, пока
потребляет всю доступную оперативную память, или, в данном случае, пока я ее не убью.

=> (список (фиб))
[1] 91474 убитых hy

Чтобы получить первые 10 чисел Фибоначчи, используйте взять, Обратите внимание, что взять также возвращает генератор,
поэтому я создаю из него список.

=> (список (возьмите 10 (фиб)))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Чтобы получить число Фибоначчи с индексом 9 (начиная с 0):

=> (nth (фиб) 9)
34

цикл
Применение: (цикл колл)

Возвращает бесконечный итератор членов coll.

=> (список (взять 7 (цикл [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (список (взять 2 (цикл [1 2 3])))
[1, 2]

отчетливый
Применение: (отчетливый колл)

Возвращает итератор, содержащий только уникальные члены в Coll.

=> (список (различные [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 Члены Coll. Поднимает ValueError if n is
отрицательный.

=> (список (drop 2 [1 2 3 4 5]))
[3, 4, 5]

=> (список (drop 4 [1 2 3 4 5]))
[5]

=> (список (drop 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (список (drop 6 [1 2 3 4 5]))
[]

последний
Применение: (последний n колл)

Возвращает итератор всех, кроме последнего n предметы в Coll. Поднимает ValueError if n is
отрицательный.

=> (список (последние 5 (диапазон 10 20)))
[10, 11, 12, 13, 14]

=> (список (последний 0 (диапазон 5)))
[0, 1, 2, 3, 4]

=> (список (последний 100 (диапазон 100)))
[]

=> (импортировать itertools)
=> (list (взять 5 (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

падение
Применение: (падение, пока PRED колл)

Возвращает итератор, пропуская члены Coll до PRED is Ложь.

=> (список (выпадение даже? [2 4 7 8 9]))
[7, 8, 9]

=> (list (drop-while numeric? [1 2 3 None "a"])))
[Нет, u'a ']

=> (список (drop-while pos? [2 4 7 8 9]))
[]

фильтр
Применение: (фильтр PRED колл)

Возвращает итератор для всех элементов в Coll которые передают предикат PRED.

Смотрите также удаление.

=> (список (позиция фильтра? [1 2 3-4 5-7]))
[1, 2, 3, 5]

=> (список (даже фильтровать? [1 2 3 -4 5-7]))
[2, -4]

расплющить
Новое в версии 0.9.12.

Применение: (сгладить колл)

Возвращает единый список всех элементов в Coll, сглаживая все содержащиеся списки и / или
кортежи.

=> (сгладить [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (сгладить ["foo" (, 1 2) [1 [2 3] 4] "bar"])
['foo', 1, 2, 1, 2, 3, 4, 'bar']

повторять
Применение: (повторять fn x)

Возвращает итератор x, fn (x), fn (fn (x)), и т.д.

=> (список (взять 5 (повторить включение 5)))
[5, 6, 7, 8, 9]

=> (list (взять 5 (iterate (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

читать
Применение: (читать &по желанию [из файла эф])

Читает следующее выражение Hy из из файла (по умолчанию sys.stdin), и может принять
один байт как EOF (по умолчанию пустая строка). Поднимает ЭООшибка if из файла заканчивается раньше
можно проанализировать полное выражение.

=> (читать)
(+2)
('+' 2 2)
=> (eval (читать))
(+2)
4

=> (импорт io)
=> (буфер определения (io.StringIO "(+ 2 2) \ n (- 2 1)"))
=> (eval (применить буфер чтения [] {"from_file"}))
4
=> (eval (применить буфер чтения [] {"from_file"}))
1

=>; предполагая, что "example.hy" содержит:
=>; (выведите «привет»)
=>; (печать «подруги!»)
=> (с [[f (open "example.hy")]]
... (пытаться
... (пока правда
... (пусть [[exp (читать f)]]
... (делать
... (выведите "OHY" exp)
... (оценочный опыт))))
... (поймать [e EOFError]
... (выведите "EOF!"))))
ОЙ ('печать' 'привет')
Здравствуйте
ОЙ («печать», «подруги!»)
подруги!
ЭОФ!

удаление
Применение: (Удалить PRED колл)

Возвращает итератор из Coll с элементами, которые передают предикат, PRED, удаленный.

Смотрите также фильтр.

=> (список (удалить нечетные? [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 (повторить «с»)))
[u's ', u's', u's ', u's', u's ', u's']

неоднократно
Применение: (неоднократно фн)

Возвращает итератор, вызывая fn неоднократно.

=> (импорт [случайный [рандинт]])

=> (list (взять 5 (несколько раз (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

взять
Применение: (взять n колл)

Возвращает итератор, содержащий первый n Члены Coll. Поднимает ValueError if n is
отрицательный.

=> (список (взять 3 [1 2 3 4 5]))
[1, 2, 3]

=> (список (взять 4 (повторить «с»)))
[u's ', u's', u's ', u's']

=> (список (взять 0 (повторить «с»)))
[]

взять
Применение: (взять n колл)

Возвращает итератор, содержащий каждый n-й член Coll.

=> (list (take-nth 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (list (take-nth 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (list (take-nth 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (list (take-nth 10 [1 2 3 4 5 6 7]))
[1]

время
Применение: (возьми, пока PRED колл)

Возвращает итератор из Coll так долго как PRED Возвращает Правда.

=> (list (take-while pos? [1 2 3-4 5]))
[1, 2, 3]

=> (list (take-while neg? [-4 -3 1 2 5]))
[-4, -3]

=> (list (take-while neg? [1 2 3 -4 5]))
[]

застежка-молния
Новое в версии 0.9.13.

Применение: (zipwith fn Coll ...)

Эквивалентно застежка-молния, но вместо создания кортежа использует функцию с несколькими аргументами. Если
застежка-молния вызывается с N коллекциями, то fn должен принимать N аргументов.

=> (оператор импорта)
=> (list (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

читатель Макрос
Макросы чтения дают Лиспу возможность изменять синтаксис на лету. Ты не хочешь
Польские обозначения? Макрос для чтения легко может это сделать. Хотите, чтобы Clojure
регулярное выражение? Макросы для чтения также могут это легко сделать.

Синтаксис
=> (defreader ^ [expr] (print expr))
=> # ^ (1 2 3 4)
(1 2 3 4)
=> # ^ "Привет"
"Привет"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

В Hy нет литерала для кортежей. Допустим, вам не нравится (, ...) и хочется чего-то другого. Этот
- это проблема, которую макросы решают аккуратно.

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

Вы даже можете сделать это, как Clojure, и иметь литерал для регулярных выражений!

=> (импорт повторно)
=> (defreader r [expr] `(re.compile ~ expr))
=> #r ". *"
<_sre.SRE_Pattern объект в 0xcv7713ph15 #>

Реализация
защитник принимает один символ в качестве имени символа для макроса считывателя; что-нибудь дольше
вернет ошибку. С точки зрения реализации, защитник расширяется в лямбду, покрытую
декоратор. Этот декоратор сохраняет лямбду в словаре с именем модуля и
символ.

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

# расширяется в (dispatch_reader_macro ...) где символ и выражение передаются в
правильная функция.

=> # ^ ()
; => (dispatch_reader_macro ^ ())
=> # ^ "Привет"
"Привет"

ПРЕДУПРЕЖДЕНИЕ:
Из-за ограничений в лексере и парсере Хай макросы чтения не могут переопределить определенные
синтаксис, такой как () [] {}. Скорее всего, этот вопрос будет решен в будущем.

внутренний Hy Документация
ПРИМЕЧАНИЕ:
Эти биты в основном полезны для людей, которые взламывают сам Hy, но также могут быть использованы для
тем, кто углубляется в программирование макросов.

Hy Модели
Введение в Hy Модели
Модели Hy - это очень тонкий слой поверх обычных объектов Python, представляющих источник Hy.
код как данные. Модели только добавляют информацию об исходной позиции и несколько методов для
поддерживать чистые манипуляции с исходным кодом Hy, например, в макросах. Чтобы добиться этого
цели, модели Hy представляют собой примеси базового класса Python и ХиОбъект.

ХиОбъект
hy.models.HyObject является базовым классом моделей Hy. Он реализует только один метод, замещать,
который заменяет исходную позицию текущего объекта на позицию, переданную в качестве аргумента.
Это позволяет нам отслеживать исходную позицию выражений, которые изменяются
макросы, будь то в компиляторе или в чистых макросах hy.

ХиОбъект не предназначен для использования непосредственно для создания экземпляров моделей Hy, а только как миксин
для других классов.

Соединение Модели
Списки в скобках и скобках анализируются парсером Hy как составные модели.

Хайлист
hy.models.list.HyList является базовым классом «итеративных» моделей Hy. Его основное использование -
представлять в квадратных скобках [] списки, которые при использовании в качестве выражения верхнего уровня преобразуются в
Литералы списка Python на этапе компиляции.

Добавление HyList к другому итерируемому объекту повторно использует класс левого объекта,
полезное поведение, например, когда вы хотите объединить объекты Hy в макрос.

Гиэкспрессия
hy.models.expression.HyExpression наследуется Хайлист для заключенных в скобки () выражения. В
результат компиляции этих выражений зависит от первого элемента списка:
компилятор отправляет выражения между специальными формами компилятора, пользовательскими макросами и
регулярные вызовы функций Python.

ГиДикт
hy.models.dict.HyDict наследуется Хайлист для фигурных скобок {} выражения, которые компилируют
вплоть до словарного литерала Python.

Решение использовать список вместо dict в качестве базового класса для ГиДикт позволяет легче
манипулирование dicts в макросах с дополнительным преимуществом разрешения составных выражений
как клавиши dict (как, например, Гиэкспрессия Класс Python не хешируется).

атомное Модели
Во входном потоке строки в двойных кавычках, соблюдая нотацию Python для строк,
анализируются как один токен, который непосредственно анализируется как Хайстринг.

Непрерывная строка символов, исключая пробелы, квадратные скобки, кавычки, двойные кавычки
и комментарии, анализируется как идентификатор.

Идентификаторы преобразуются в атомарные модели на этапе синтаксического анализа в следующем порядке:

· HyInteger

· ХайФлоат

· ХайКомплекс (если атом не голый j)

· HyКлючевое слово (если атом начинается с :)

· Хайсимвол

Хайстринг
hy.models.string.HyString является базовым классом струнно-эквивалентных моделей Hy. Это также
представляет строковые литералы в двойных кавычках, "", которые компилируются в строку Unicode
литералы в Python. HyStrings наследовать объекты Unicode в Python 2 и строковые объекты в
Python 3 (и поэтому не зависят от кодировки).

Хайстринг модели на основе неизменяемы.

Буквальные строки Hy могут охватывать несколько строк и рассматриваются синтаксическим анализатором как единое целое.
unit, соблюдая escape-последовательности Python для строк Unicode.

Числовой Модели
hy.models.integer.HyInteger представляет целочисленные литералы (используя длинной введите на Python 2,
и Int на Python 3).

hy.models.float.HyFloat представляет литералы с плавающей запятой.

hy.models.complex.HyComplex представляет собой сложные литералы.

Числовые модели анализируются с использованием соответствующей подпрограммы Python и действительного числового Python.
литералы будут преобразованы в их копию Hy.

Хайсимвол
hy.models.symbol.HySymbol это модель, используемая для представления символов на языке Hy. Это
наследуется Хайстринг.

Хайсимвол объекты изменяются на этапе синтаксического анализа, чтобы улучшить совместимость Python:

· Символы, окруженные звездочками (*) переводятся в верхний регистр;

· Дефисы (-) превращаются в символы подчеркивания (_);

· Один знак вопроса в конце (?) превращается в ведущую является_.

Предостережение: поскольку изменение выполняется на этапе синтаксического анализа, можно
программно генерировать HySymbols, которые нельзя сгенерировать с исходным кодом Hy. Такой
Механизм используется gensym для генерации «неорганизованных» символов.

HyКлючевое слово
hy.models.keyword.HyKeyword представляет ключевые слова в Hy. Ключевые слова - это символы, начинающиеся с
a :. Класс наследует Хайстринг.

Различать ГиКлючевые слова от ХайСимволс, без возможности (непроизвольного)
столкновения, символ Юникода частного использования "\ uFDD0" добавляется к литералу ключевого слова
перед хранением.

Минусы Клетки
hy.models.cons.HyCons представляет собой представление Python-дружественного минусы клеток. Минусы ячеек
особенно полезен для имитации функций «обычных» вариантов LISP, таких как Scheme или Common
Лисп.

Консольная ячейка - это объект из двух элементов, содержащий автомобиль (голова) и корд (хвостик). В каком-то Лиспе
вариантов, cons-ячейка является фундаментальным строительным блоком, а S-выражения на самом деле
представлены в виде связанных списков cons-ячеек. В Hy это не так, как обычно.
выражения состоят из списков Python, заключенных в Гиэкспрессия. Тем не менее, ХайКонс
имитирует поведение "обычных" вариантов Lisp таким образом:

· (минусы удалось ноль) is (HyExpression [что-то])

· (минусы удалось какой-то список) is ((тип какой-то список) (+ [что-то] какой-то список)) (если
какой-то список наследуется от список).

· (получать (минусы a b) 0) is a

· (кусочек (минусы a b) 1) is b

Hy поддерживает синтаксис с пунктирным списком, где '(а . b) означает (минусы 'a б) и '(а b . c) означает
(минусы 'a (минусы 'b 'в)). Если компилятор встречает cons-ячейку на верхнем уровне, он вызывает
ошибка компиляции.

ХайКонс оборачивает переданные аргументы (car и cdr) в типы Hy, чтобы упростить манипуляции с
cons-ячейки в контексте макроса.

Hy внутренний теория
Обзор
Внутренние компоненты Hy работают, выступая в качестве внешнего интерфейса для байт-кода Python, так что сам Hy
компилируется в байт-код Python, позволяя неизмененной среде выполнения Python запускать код Hy,
даже не замечая этого.

Мы делаем это, переводя Hy во внутреннюю структуру данных Python AST, и
построение этого AST в байт-коде Python с использованием модулей из стандарта Python
библиотеки, так что нам не нужно дублировать всю работу внутренних компонентов Python для каждого
единственная версия Python.

Хай работает в четыре этапа. Следующие разделы охватывают каждый шаг Hy от источника до
время выполнения.

Шаги 1 и 2: Tokenizing и анализ
Первым этапом компиляции Hy является преобразование исходного кода в токены, с которыми мы можем иметь дело. Мы
используйте проект под названием rply, который является действительно хорошим (и быстрым) парсером, написанным в подмножестве
Python называется rpython.

Лексический код полностью определен в hy.lex.lexer. Этот код в основном просто определяет Hy
грамматика, а обо всех сложных частях позаботится rply - мы просто определяем
"обратные вызовы" для rply в hy.lex.parser, который берет сгенерированные токены и возвращает
Hy модели.

Вы можете думать о моделях Hy как о «AST» для Hy, это то, над чем работают макросы.
(напрямую), и это то, что компилятор использует при компилировании Hy.

СМ ТАКЖЕ:
Раздел Hy Модели для получения дополнительной информации о моделях Hy и их значении.

Шаг 3: Hy Сборник в Питон АСТ
Именно здесь происходит большая часть волшебства Хай. Здесь мы берем Hy AST (модели),
и скомпилируйте их в Python AST. Здесь происходит пара забавных вещей, которые сработают после нескольких
проблемы в AST, и работа с компилятором - одна из самых важных работ, которые мы делаем
иметь.

Компилятор немного сложен, так что не расстраивайтесь, если вы не попробуете его с первого взгляда,
это может занять некоторое время.

Основная точка входа в компилятор: HyASTCompiler.compile. Этот метод вызывается, и
единственный настоящий «общедоступный» метод класса (то есть мы не обещаем
API за пределами этого метода).

Фактически, даже внутренне мы почти никогда не рекурсируем напрямую, мы почти всегда заставляем
дерево Хай через компилировать, и часто будет делать это с подэлементами выражения
что у нас есть. Диспетчер на основе типов должен правильно отправлять подэлементы.

Все методы, выполняющие компиляцию, отмечены значком @builds () декоратор. Ты сможешь
либо передайте класс модели Hy, которую он компилирует, либо вы можете использовать строку для
выражения. Я проясню это через секунду.

First Этап Тип-отправка
Начнем с компилировать метод. Первое, что мы делаем, это проверяем Тип вещи.
мы строим. Мы смотрим вверх, чтобы увидеть, есть ли у нас метод, который может построить тип() что мы
иметь и отправить в метод, который может с этим справиться. Если у нас нет методов, которые могут
строим этот тип, мы поднимаем внутренний Исключение.

Например, если у нас есть Хайстринг, у нас есть почти однозначное отображение Hy AST на Python
AST. В компиляция_строка метод принимает Хайстринг, и возвращает ast.Str ()
заполнены правильными номерами строк и содержимым.

Макро-развернуть
Если мы получим Гиэкспрессия, мы попытаемся узнать, является ли это известным макросом, и подтолкнем его к
он расширился, вызвав hy.macros.macroexpand, затем верните результат в
HyASTCompiler.compile.

Во-вторых Этап Экспресс-отправка
Единственный особый случай - это Гиэкспрессия, так как нам нужно создать разные AST в зависимости от
на рассматриваемой специальной форме. Например, когда мы нажимаем (если правда правда ложный), Мы
необходимо создать аст. если, и правильно скомпилировать подузлы. Вот где @builds ()
со строкой в ​​качестве аргумента.

Для того, чтобы получить compile_expression (который определяется с помощью @builds (HyExpression)) отправлю
на основе строки первого аргумента. Если по какой-то причине первый аргумент не
строка, он также правильно обработает этот случай (скорее всего, подняв Исключение).

Если строка не известна Hy, по умолчанию создается ast.Call, который попытается
выполнить вызов времени выполнения (в Python что-то вроде foo ()).

Темы Удар Питон АСТ
Python AST великолепен; это то, что позволило нам написать такой мощный проект поверх
Python без необходимости слишком усердно бороться с Python. Как и все, у нас была своя доля
проблемы, и вот краткий список наиболее распространенных из них, с которыми вы можете столкнуться.

Питон дифференциатами между Отчеты и Expressions.

Это может показаться неважным - на самом деле, для большинства программистов Python это будет
скоро станет моментом "Ну, да".

В Python сделать что-то вроде:

Распечатать для x in ассортимент(10): pass, потому как Распечатать печатает выражения и для не
выражение, это оператор потока управления. Вещи как 1 + 1 Выражения, как есть лямбда
x: 1 + x, но другие языковые функции, такие как if, дляили в то время как являются заявлениями.

Поскольку они не имеют "ценности" для Python, это усложняет работу в Hy, поскольку что-то
такое как (Распечатать (если правда правда ложный)) не просто обычное дело, это ожидаемо.

В результате мы автоматически искажаем вещи, используя Результат объект, где мы предлагаем любые аст.стмт
что нужно бежать, и один ast.expr которые можно использовать для получения ценности чего угодно
был просто запущен. Хай делает это, заставляя выполнять задания во время бега.

Например, Hy:

(печать (если правда правда ложь))

Превратится в:

если правда:
_mangled_name_here = Верно
еще:
_mangled_name_here = Ложь

напечатать _mangled_name_here

Хорошо, это было немного неправдой, поскольку мы фактически превращаем это утверждение в:

напечатать True, если True, иначе False

Заставляя вещи в ast.expr если сможем, но общая идея остается в силе.

Шаг 4: Питон Байт-код Результат и Время выполнения
После того, как у нас будет готовое дерево AST Python, мы можем попробовать скомпилировать его в Python.
байт-код, проталкивая его Eval. С этого момента мы больше не контролируем ситуацию, и
Python обо всем позаботится. Вот почему такие вещи, как трассировки Python, pdb и
Приложения django работают.

Hy Макрос
. генсим для безопаснее Макрос
При написании макросов нужно быть осторожным, чтобы избежать захвата внешних переменных или использования
имена переменных, которые могут конфликтовать с пользовательским кодом.

Мы будем использовать пример макроса NIF (См.
http://letoverlambda.com/index.cl/guest/chap3.html# sec_5 для более полного описания.)
NIF это пример, что-то вроде числового if, где на основе выражения одна из
3 формы вызываются в зависимости от того, является ли выражение положительным, нулевым или отрицательным.

Первый проход может выглядеть примерно так:

(defmacro nif [expr pos-form нулевая форма neg-form]
`(пусть [[неясное-имя ~ выражение]]
(cond [(pos? obscure-name) ~ pos-form]
[(ноль? неясное-имя) ~ нулевая форма]
[(нег? неясное-имя) ~ нег-форма])))

в котором непонятное имя это попытка выбрать имя одной переменной, чтобы не конфликтовать с другими
код. Но, конечно, хотя это сделано из лучших побуждений, это не гарантия.

Метод gensym разработан для создания нового уникального символа именно для такого случая.
Намного лучшая версия NIF было бы:

(defmacro nif [expr pos-form нулевая форма neg-form]
(пусть [[g (gensym)]]
`(пусть [[~ g ~ expr]]
(cond [(pos? ~ g) ~ pos-form]
[(ноль? ~ g) ~ нулевая форма]
[(нег? ~ г) ~ нег-форма]))))

Это простой случай, поскольку здесь всего один символ. Но если есть необходимость в нескольких
gensym's есть второй макрос с -gensyms, который в основном расширяется до ряда позволять
заявления:

(with-gensyms [abc]
...)

расширяется до:

(пусть [[a (gensym)
[b (генсим)
[с (генсим)]]
...)

так что наш переписанный NIF будет выглядеть так:

(defmacro nif [expr pos-form нулевая форма neg-form]
(with-gensyms [г]
`(пусть [[~ g ~ expr]]
(cond [(pos? ~ g) ~ pos-form]
[(ноль? ~ g) ~ нулевая форма]
[(нег? ~ г) ~ нег-форма]))))

Наконец, мы можем создать новый макрос, который сделает все это за нас. defmacro / g! примет
все символы, начинающиеся с g! и автоматически звонить генсим с остатком
символ. Так г! а станет (генсим "а").

Наша финальная версия NIF, построенный с defmacro / g! будет выглядеть так:

(defmacro / g! nif [expr pos-form zero-form neg-form]
`(пусть [[~ g! res ~ expr]]
(cond [(pos? ~ g! res) ~ pos-form]
[(zero? ~ g! res) ~ zero-form]
[(neg? ~ g! res) ~ neg-form]))))

Контроль Макрос аргументы и Привлечение Исключения
Hy составитель Встроенный Ins

АВТОР МОДУЛИ ИНДЕКС

Содержание:

анафорных Макрос
Новое в версии 0.9.12.

Модуль анафорических макросов делает функциональное программирование на Hy очень кратким и простым в использовании.
читать.
Анафорический макрос - это тип программного макроса, который намеренно фиксирует некоторую форму
передается в макрос, на который может ссылаться анафора (выражение, относящееся к
другому). - Википедия (http://en.wikipedia.org/wiki/Anaphoric_macro)

Макрос
п-если
Применение: (ап-если (фу) (Распечатать Это))

Оценивает правдивость первой формы и связывает ее с it как в истинном, так и в ложном
ветви.

персик
Применение: (персик [1 2 3 4 5] (Распечатать Это))

Оцените форму для каждого элемента в списке на предмет побочных эффектов.

ап-каждое время
Применение: (AP-каждый-в то время как список PRED тело)

Оцените форму для каждого элемента, в котором форма предиката возвращает Правда.

=> (ap-each-while [1 2 3 4 5 6] (<it 4) (распечатать))
1
2
3

AP-карта
Применение: (AP-карта форма список)

Анафорическая форма карты работает так же, как обычная карта, за исключением того, что вместо функции
объект принимает форму Hy. Особое имя it привязан к текущему объекту из
список в итерации.

=> (список (ap-map (* it 2) [1 2 3]))
[2, 4, 6]

ap-карта-когда
Применение: (AP-карта-когда пред репутация список)

Оцените сопоставление по списку, используя функцию предиката, чтобы определить, когда применять
форме.

=> (list (ap-map-when odd? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (list (ap-map-when even? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-фильтр
Применение: (ap-фильтр форма список)

Как и в случае AP-карта мы берем специальную форму вместо функции для фильтрации элементов
список. Особое имя it привязан к текущему элементу в итерации.

=> (list (ap-filter (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]

ап-отклонить
Применение: (ап-отклонить форма список)

Эта функция противоположна ap-фильтр, он отклоняет элементы, прошедшие
предикат. Особое имя it привязан к текущему элементу в итерации.

=> (list (ap-reject (> (* it 2) 6) [1 2 3 4 5]))
[1, 2, 3]

подходящее время
Применение (время n тело)

Эта функция оценивает тело n раз, со специальной переменной it связан с 0 в
1-н. Это полезно при побочных эффектах.

=> (setv n [])
=> (ap-dotimes 3 (. добавить его))
=> п
[0, 1, 2]

ап-первый
Применение (ап-первый пред список)

Эта функция возвращает первый элемент, который передает предикат или Ничто, С
специальная переменная it привязан к текущему элементу в итерации.

=> (ap-first (> it 5) (диапазон 10))
6

ап-последний
Применение (ап-последний пред список)

Эта функция возвращает последний элемент, который передает предикат или Ничто, с особым
переменная it привязан к текущему элементу в итерации.

=> (ap-last (> it 5) (диапазон 10))
9

ap-уменьшить
Применение (ap-уменьшить форма список &по желанию Первоначальный значение)

Эта функция возвращает результат применения формы к первым двум элементам тела и
применение результата и 3-го элемента и т. д., пока список не будет исчерпан. Необязательно
можно указать начальное значение, поэтому функция будет применена к начальному значению и
вместо этого первый элемент. Это показывает элемент, который повторяется как it И текущий
накопленная стоимость как акк.

=> (ap-reduce (+ it acc) (диапазон 10))
45

цикл / повтор
Новое в версии 0.10.0.

Ассоциация поиска / рецидивировать макрос дает программистам простой способ использовать оптимизацию хвостового вызова (TCO)
в их коде Hy.
Хвостовой вызов - это вызов подпрограммы, который происходит внутри другой процедуры как ее последний вызов.
действие; он может выдать возвращаемое значение, которое затем немедленно возвращается вызывающим
процедура. Если какой-либо вызов, выполняемый подпрограммой, может в конечном итоге привести к
к этой же подпрограмме, вызываемой снова в цепочке вызовов, находится в хвостовой позиции,
такая подпрограмма называется хвостовой рекурсией, что является частным случаем рекурсии.
Хвостовые вызовы важны, потому что их можно реализовать без добавления нового стека.
кадр в стек вызовов. Большая часть кадра текущей процедуры не нужна ни
больше, и его можно заменить рамкой хвостового вызова. Затем программа может перейти
в вызываемую подпрограмму. Создание такого кода вместо стандартной последовательности вызовов
называется устранением хвостового вызова или оптимизацией хвостового вызова. Устранение хвостового звонка позволяет
вызовы процедур в хвостовой позиции должны быть реализованы так же эффективно, как операторы goto,
тем самым позволяя эффективно структурированное программирование. - Википедия (-
http://en.wikipedia.org/wiki/Tail_call)

Макрос
поиска
поиска устанавливает точку рекурсии. С участием поиска, рецидивировать повторно связывает переменные, установленные в
точку рекурсии и отправляет выполнение кода обратно в эту точку рекурсии. Если рецидивировать используется в
позиция без хвоста, генерируется исключение.

Применение: (петля переплеты &отдых тело)

Пример:

(требуется hy.contrib.loop)

(defn факториал [n]
(цикл [[in] [acc 1]]
(если (ноль? я)
акк
(повторение (dec i) (* acc i)))))

(факториал 1000)

дефмульти
Новое в версии 0.10.0.

дефмульти позволяет вам перегрузить функцию по заданному количеству аргументов и / или kwargs.
Вдохновленный подходом Clojure определение.

=> (требуется hy.contrib.multi)
=> (defmulti весело
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (удовольствие 1)
«А»
=> (удовольствие 1 2)
"ab"
=> (удовольствие 1 2 3)
"abc"

ВЗЛОМ ON HY

Присоединиться наши Хайв!
Пожалуйста, давай взломай Хай!

Пожалуйста, пообщайся с нами #хй on irc.freenode.net!

Пожалуйста, поговорите об этом в Твиттере с #хй хэштегом!

Пожалуйста, напишите об этом в блоге!

Пожалуйста, не красьте им забор вашего соседа (не спрашивая любезно)!

Взломать!
Сделай это:

1. Создать виртуальный охрана окружающей среды:

$ виртуальный венв

и активируйте его:

$. Venv / bin / активировать

или использование виртуальная обертка для создания и управления вашей виртуальной средой:

$ mkvirtualenv hy
$ работает на хай

2. Получите исходный код:

$ git клон https://github.com/hylang/hy.git

или воспользуйтесь вилкой:

$ git клон [электронная почта защищена]: /hy.git

3. Установить для взлома:

$ cd hy /
$ pip install -e.

4. Установите другие требования для разработки:

$ pip install -r требования-dev.txt

5. Делайте потрясающие вещи; заставить кого-то вскрикнуть от восторга / отвращения к тому, что вы сделали.

Испытание!
Тесты находятся в тесты /, Мы используем нос.

Чтобы запустить тесты:

$ Nostests

Пишите тесты --- тесты хороши!

Кроме того, рекомендуется запускать тесты для всех поддерживаемых платформ и для совместимости с PEP 8.
код. Вы можете сделать это, запустив tox:

$ токсик

Документ!
Документация находится в документы /, Мы используем Сфинкс.

Чтобы создать документы в HTML:

$ cd документы
$ сделать html

Пишите документы --- документы хороши! Даже этот документ!

Содействие
Взносы приветствуются и очень ценятся, каждый маленький кусочек помогает сделать Хай больше.
здорово.

Запросы на вытягивание - это здорово! Мы любим их; вот краткое руководство:

· Разветвите репо и создайте тематическую ветку для функции / исправления. Избегайте внесения изменений напрямую
на главной ветке.

· Все поступающие функции должны сопровождаться тестами.

· Перед тем, как отправить PR, запустите тесты и проверьте свой код на соответствие стилю
руководство. Вы можете делать обе эти вещи одновременно:

$ сделать д

· Делайте коммиты в логические блоки, чтобы их было легче отслеживать и перемещаться позже. До
отправляя PR, попробуйте разбить коммиты в наборы изменений, к которым легко вернуться
позже. Также убедитесь, что вы не оставляете ложных пробелов в наборах изменений; это
позволяет избежать создания фиксации исправления пробелов позже.

· Что касается сообщений о фиксации, постарайтесь придерживаться следующего:

· Попробуйте придерживаться ограничения в 50 символов для первой строки сообщений Git о фиксации.

· Для получения дополнительных сведений / объяснений введите пустую строку и продолжите
подробное описание коммита.

· Наконец, добавьте себя в файл AUTHORS (как отдельный коммит): вы это заслужили :)

· Все входящие изменения должны быть подтверждены двумя разными членами основной команды Hylang.
Дополнительное рассмотрение явно приветствуется, но нам нужно как минимум 2 подписи для любого
измениться.

· Если основной член отправляет PR, пожалуйста, найдите 2 основных члена, которые не включают
Публикация PR. Идея здесь в том, что один может работать с автором PR, а второй - подтверждать.
весь набор изменений.

· Что касается документации и других тривиальных изменений, мы можем выполнить слияние после одного ACK. Мы получили
низкий уровень покрытия, поэтому было бы здорово сохранить этот барьер на низком уровне.

Основные Команда
Основная команда разработчиков Hy состоит из следующих разработчиков:

· Жюльен Danjou

· Мортен Линдеруд

· J Кеннет Король

· Gergely Надь

· Туукка Турто

· Карен Рустад

· Абхишек L

· Кристофер Аллан Уэббер

· Konrad Хинсен

· Будет Кан-Грин

· Пол Тальямонте

· никола Дандримонт

· боб Тольберт

· Berker Пексаг

· Клинтон N. Dreisbach

· гостиница semaj

Используйте hy онлайн с помощью сервисов onworks.net