이것은 Ubuntu Online, Fedora Online, Windows 온라인 에뮬레이터 또는 MAC OS 온라인 에뮬레이터와 같은 여러 무료 온라인 워크스테이션 중 하나를 사용하여 OnWorks 무료 호스팅 제공업체에서 실행할 수 있는 명령입니다.
프로그램:
이름
hy - hy 문서 [이미지: Hy] [이미지]
시험 Hy https://try-hy.appspot.com
PyPI https://pypi.python.org/pypi/hy
출처 https://github.com/hylang/hy
명부 하일랑 토론
IRC #hy 프리노드에서
짓다 지위
트래비스 CI.UNINDENT
Hy는 Python에 내장된 훌륭한 Lisp 방언입니다.
Hy는 Lisp 코드를 Python 추상 구문 트리로 변환하므로 다음과 같습니다.
Lisp 형식으로 Python의 아름다운 세계 전체를 손끝에서 만나보세요!
내용 :
빠른 시작
[이미지: Karen Rustard의 포옹] [이미지]
(껴안아주신 Karen Rustad에게 감사드립니다!)
주문 제작 ~까지 바로 HY 레알 FAST:
1. 만들기 온라인 Python 환경.
2. 가상 Python 환경을 활성화합니다.
3. 설치 hy 에 PyPI 과 삐악 삐악 울다 설치 hy.
4. 다음으로 REPL을 시작하세요. hy.
5. REPL에 내용을 입력합니다.
=> ("Hy!" 인쇄)
여기요!
=> (defn salutationsnm [이름] (인쇄 (+ "Hy " 이름 "!")))
=> (인사말 "귀하의 이름")
하이 유어네임!
등
6. 완료되면 CTRL-D를 누르십시오.
OMG! 그건 놀라운! I 필요 에 쓰다 a Hy 프로그램)
7. 엘리트 프로그래밍 편집기를 열고 다음을 입력하십시오.
("Python 구문으로 코딩하려고 했는데 Hy를 얻었습니다." 인쇄)
8. 다른 이름으로 저장 굉장해.하이.
9. 그리고 첫 번째 Hy 프로그램을 실행합니다.
안녕 대단해.하이
10.
과호흡이 되지 않도록 심호흡을 하세요.
11.
악랄하게 웃으며 비밀리에 숨어들어 말할 수 없는 짓을 하세요.
이용 가이드
Hy 튜토리얼에 오신 것을 환영합니다!
간단히 말해서 Hy는 Lisp 방언이지만 그 구조를 Python으로 변환하는 방언입니다.
말 그대로 Python의 추상 구문 트리로의 변환입니다! (아니면 좀 더 조잡하게 표현하자면
용어, Hy는 Python에서 리스프 스틱입니다!)
이는 Hy가 여러 가지를 의미한다는 점에서 매우 좋습니다.
· 매우 Pythonic한 느낌을 주는 Lisp
· Lispers의 경우, Lisp의 엄청난 능력을 사용하는 좋은 방법이지만 Python의 넓은 세계에서
라이브러리(그렇습니다. 이제 Lisp에서 Django 애플리케이션을 작성할 수 있습니다!)
· Pythonistas를 위한 Python의 편안함에서 Lisp 탐색을 시작하는 좋은 방법입니다!
· 모두를 위한: 깔끔한 아이디어가 가득한 즐거운 언어!
Basic 소개 에 혀가 잘 돌지 않은 발음 for 비단뱀
좋습니다. 아마도 이전에 Lisp를 사용해 본 적이 없지만 Python은 사용해 본 적이 있을 것입니다!
Hy의 "hello world" 프로그램은 실제로 매우 간단합니다. 해 보자:
("hello world" 인쇄)
보다? 쉬운! 짐작할 수 있듯이 이는 다음의 Python 버전과 동일합니다.
"hello world"를 인쇄하세요
매우 간단한 수학을 추가하려면 다음을 수행할 수 있습니다.
(+ 1 3)
이는 4를 반환하고 다음과 같습니다.
1 + 3
여러분이 주목하게 될 것은 목록의 첫 번째 항목이 호출되는 함수이고
나머지 인수는 전달되는 인수입니다. 실제로 Hy에서는(대부분의 인수와 마찬가지로)
Lips) 더하기 연산자에 여러 인수를 전달할 수 있습니다.
(+ 1 3 55)
그러면 59가 반환됩니다.
어쩌면 당신은 이전에 Lisp에 대해 들어본 적이 있지만 그것에 대해 많이 알지 못할 수도 있습니다. 리스프는 너만큼 어렵지 않아
라고 생각할 수도 있고 Hy는 Python을 상속하므로 Hy는 Lisp 학습을 시작하는 좋은 방법입니다.
Lisp에서 가장 분명한 점은 괄호가 많다는 것입니다. 이건 아마도
처음에는 혼란스러워 보이지만 그렇게 어렵지는 않습니다. 간단한 수학을 살펴보겠습니다.
Hy 인터프리터에 입력할 수 있는 여러 개의 괄호로 묶였습니다.
(setv 결과 (- (/ (+ 1 3 88) 2) 8))
그러면 38이 반환됩니다. 그런데 왜 그럴까요? 음, 우리는 다음과 같은 표현을 볼 수 있습니다:
파이썬 :
결과 = ((1 + 3 + 88) / 2) - 8
위의 내용이 Python에서 어떻게 작동하는지 알아내려면 물론
각 안의 괄호를 풀어 결과를 알아보세요. 그것은 동일한 기본 아이디어입니다.
하이. 먼저 Python에서 이 연습을 시도해 보겠습니다.
결과 = ((1 + 3 + 88) / 2) - 8
# 단순화...
결과 = (92 / 2) - 8
# 단순화...
결과 = 46 - 8
# 단순화...
결과 = 38
이제 Hy에서 동일한 작업을 시도해 보겠습니다.
(setv 결과 (- (/ (+ 1 3 88) 2) 8))
; 단순화하다...
(setv 결과 (- (/ 92 2) 8))
; 단순화하다...
(setv 결과 (- 46 8))
; 단순화하다...
(setv 결과 38)
아마 짐작하셨겠지만, 이 마지막 표현은 세트 변수를 할당한다는 의미
"결과"를 38로 변경합니다.
보다? 너무 어렵지 않아요!
이것이 Lisp의 기본 전제입니다. Lisp는 "목록 처리"를 나타냅니다. 이는 다음을 의미합니다.
프로그램의 구조는 실제로 목록의 목록입니다. (파이썬에 익숙하다면
목록에서 위와 같은 전체 구조를 상상해 보세요. 대신 대괄호를 사용하면 됩니다.
위의 구조를 프로그램과 데이터 구조로 볼 수 있습니다.) 이것은
더 많은 예제를 통해 이해하기 쉽도록 간단한 Python 프로그램을 작성하고 테스트해 보겠습니다.
그런 다음 동등한 Hy 프로그램을 표시합니다.
데프 simple_conversation():
print "안녕하세요! 당신에 대해 알고 싶습니다. 당신에 대해 말해주세요!"
name = raw_input("이름이 무엇입니까?")
age = raw_input("당신의 나이는 몇 살입니까?")
print "안녕하세요 " + 이름 + "! 당신은 " + 나이 + " 살이군요."
simple_conversation()
이 프로그램을 실행하면 다음과 같을 것입니다:
안녕하세요! 나는 당신을 알고 싶습니다. 당신에 대해 말해주세요!
이름이 뭐에요? 게리
당신의 나이는 몇 살입니까? 38
안녕 게리! 그러고 보니 당신은 38세입니다.
이제 동등한 Hy 프로그램을 살펴보겠습니다.
(간단한 대화 [] 정의
(인쇄 "안녕하세요! 당신에 대해 알고 싶습니다. 당신에 대해 말해주세요!")
(setv 이름(원시 입력 "이름이 무엇입니까?"))
(setv age(원시 입력 "당신의 나이는 무엇입니까?"))
(print (+ "Hello " name "! 당신은 "
나이 " 세.")))
(간단한 대화)
위 프로그램을 보면 각 항목의 첫 번째 요소가
프로그램 목록은 호출되는 함수(또는 매크로... 이에 대해서는 나중에 설명하겠습니다)입니다.
나머지는 주장이므로 이것이 무엇을 의미하는지 알아내는 것은 매우 쉽습니다.
(아마도 짐작하셨겠지만, 데프 방법을 정의하는 Hy 방법입니다.)
그래도 많은 사람들이 처음에는 괄호가 너무 많아서 혼란스러워합니다.
하지만 이를 더 쉽게 만드는 데 도움이 될 수 있는 것들이 많이 있습니다. 들여쓰기를 좋게 유지하고
괄호 일치 기능이 있는 편집기를 사용하십시오(이것은 각각의 내용을 파악하는 데 도움이 됩니다).
괄호가 와 짝을 이루면 상황이 편안해지기 시작할 것입니다.
실제로 매우 간단한 데이터인 코드 구조를 갖는 데에는 몇 가지 장점이 있습니다.
Lisp의 핵심은 구조를 기반으로합니다. 우선, 이는 귀하의 프로그램이
분석하기 쉽고 프로그램의 전체 실제 구조가 매우 명확하게 노출됩니다.
당신에게. (hy에는 보이는 구조가 Python의 구조로 변환되는 추가 단계가 있습니다.
자신의 표현 ... Common Lisp 또는 Emacs Lisp와 같은 "순수한" Lisp에서 데이터
코드에서 볼 수 있는 구조와 실행되는 데이터 구조는 훨씬 더 많습니다.
말 그대로 닫혀있습니다.)
이것의 또 다른 의미는 매크로입니다: 프로그램의 구조가 단순한 데이터인 경우
즉, 코드를 매우 쉽게 작성할 수 있는 코드를 작성할 수 있다는 의미입니다.
완전히 새로운 언어 기능을 구현하는 것은 매우 빠릅니다. Hy 이전에는 그렇지 않았습니다.
Python 프로그래머에게는 매우 가능합니다. 이제 여러분도 매크로의 놀라운 기능을 사용할 수 있습니다.
힘을 주세요(발을 겨냥하지 않도록 주의하세요)!
Hy is a 리스프맛 Python
Hy는 Python 고유의 추상 구문 트리로 변환하므로 곧 모든 것을 발견하게 될 것입니다.
파이썬의 친숙한 힘을 여러분의 손끝에서 만나보세요.
Hy에서 Python의 데이터 유형 및 표준 라이브러리에 대한 전체 액세스 권한을 갖습니다. 실험해보자
hy 인터프리터에서는 다음과 같이 합니다.
=> [1 2 3]
[1, 2, 3]
=> {"개" "짖다"
... "고양이" "야옹"}
...
{'개': '짖다', '고양이': '야옹'}
=> (, 1 2 3)
(1, 2, 3)
다른 Lisp에 익숙하다면 Hy가 Common을 지원한다는 사실에 관심이 있을 수 있습니다.
Lisp 인용 방법:
=> '(1 2 3)
(1L 2L 3L)
또한 모든 내장 유형의 멋진 메소드에 액세스할 수 있습니다.
=> (.strip " fooooo ")
"푸오오오"
이건 뭐죠? 예, 실제로 이것은 다음과 정확히 동일합니다.
" fooooo ".strip()
맞습니다---점 표기법을 사용한 Lisp! 이 문자열을 변수로 할당하면
다음 작업도 수행할 수 있습니다.
(setv 이 문자열 " fooooo ")
(이-문자열.스트립)
조건문은 어떻습니까?:
(if (뭔가를 시도해 보세요)
("이것이 사실이라면"을 인쇄하세요)
("이것은 거짓인 경우입니다" 인쇄))
위에서 알 수 있듯이 첫 번째 주장은 if 는 진실 테스트입니다. 두 번째 인수는 다음과 같습니다.
true이면 본문이고, 세 번째 인수(선택 사항!)는 false인 경우입니다(예: 그렇지 않으면).
더 복잡한 조건문을 수행해야 하는 경우에는 다음이 없다는 것을 알게 될 것입니다. ELIF
Hy에서 사용 가능합니다. 대신에 다음과 같은 것을 사용해야 합니다. 조건. Python에서는 다음을 수행할 수 있습니다.
뭔가 :
somevar = 33
somevar > 50인 경우:
print "그 변수는 너무 큽니다!"
elif somevar < 10:
print "그 변수는 너무 작습니다!"
그밖에:
print "그 변수는 정말 옳습니다!"
Hy에서는 다음을 수행합니다.
(조건
[(> somevar 50)
("그 변수는 너무 큽니다!" 인쇄)]
[(< 일부 변수 10)
("그 변수는 너무 작습니다!" 인쇄)]
[진실
("그 변수는 정말 옳아요!"를 인쇄하세요.)])
당신이 주목하게 될 것은 조건 실행되는 일부 명령문 사이를 끄고
조건에 따라 참 또는 거짓인지 확인한 다음, 결과가 바뀌면 실행할 약간의 코드
사실로 밝혀졌습니다. 당신은 또한 그렇지 않으면 마지막에 간단히 구현됩니다.
확인 참된 -- 그것은 ~ 때문에 참된 항상 사실이므로 여기까지 도달하면
항상 저걸 실행하세요!
다음과 같은 코드가 있는 경우 위에서 알 수 있습니다.
(어떤 조건이 있는 경우
(본문이 true인 경우)
(본문이 거짓인 경우))
하지만 기다려! 다음 중 하나의 본문에서 둘 이상의 명령문을 실행하려면 어떻게 해야 합니까?
이것들?
다음을 수행할 수 있습니다.
(if (뭔가를 시도해 보세요)
(정당한
("이것이 사실이라면"을 인쇄하세요)
(인쇄 "그리고 왜 안되는지, 그것이 얼마나 사실인지 계속 이야기합시다!))
("이것은 여전히 단순히 거짓입니다"를 인쇄하세요))
우리가 사용한 것을 볼 수 있습니다 do 여러 문을 래핑합니다. 다른 것에 대해 잘 알고 계시다면
Lips는 다음과 같습니다. 예측 다른.
주석은 세미콜론으로 시작합니다.
("이것은 실행될 것입니다"를 인쇄)
; ("그러나 이것은 그렇지 않을 것이다"라고 인쇄)
(+ 1 2 3) ; 우리는 추가를 실행할 것이지만 이 주석은 실행하지 않을 것입니다!
루핑은 어렵지 않지만 일종의 특별한 구조를 가지고 있습니다. Python에서는 다음을 수행할 수 있습니다.
나를 위해 범위(10) :
print "'i'는 이제 " + str(i)에 있습니다.
Hy의 해당 항목은 다음과 같습니다.
([i(범위 10)]의 경우
(인쇄 (+ "'i'는 이제 " (str i))))
다양한 Python 라이브러리를 가져와서 활용할 수도 있습니다. 예를 들어:
(가져오기 운영 체제)
(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
("야, 그 길은 거기에 없어!" 인쇄))
Python의 컨텍스트 관리자(과 문)은 다음과 같이 사용됩니다.
([[f ("/tmp/data.in" 열기)]] 사용
(인쇄(.read f)))
다음과 동일합니다.
open("/tmp/data.in")을 f로 사용:
f.read()를 인쇄합니다.
그리고 그렇습니다. 우리는 List comprehension을 가지고 있습니다! Python에서는 다음을 수행할 수 있습니다.
확률 제곱 = [
펑(숫자, 2)
숫자 입력 범위(100)
숫자 % 2 == 1인 경우]
Hy에서는 다음과 같이 할 수 있습니다.
(setv 승산제곱
(목록 구성 요소
(전원 번호 2)
(숫자(범위 100))
(= (% 숫자 2) 1)))
; 그리고 Clojure 페이지에서 뻔뻔스럽게 도용된 예도 있습니다.
; 체스판의 모든 블록을 나열해 보겠습니다.
(목록 구성 요소
(, XY)
(x(범위 8)
y "ABCDEFGH"))
; [(0, 'A'), (0, 'B'), (0, 'C'), (0, 'D'), (0, 'E'), (0, 'F'), ( 0, 'G'), (0, 'H'),
; (1, 'A'), (1, 'B'), (1, 'C'), (1, 'D'), (1, 'E'), (1, 'F'), (1 , 'G'), (1, 'H'),
; (2, 'A'), (2, 'B'), (2, 'C'), (2, 'D'), (2, 'E'), (2, 'F'), (2 , 'G'), (2, 'H'),
; (3, 'A'), (3, 'B'), (3, 'C'), (3, 'D'), (3, 'E'), (3, 'F'), (3 , 'G'), (3, 'H'),
; (4, 'A'), (4, 'B'), (4, 'C'), (4, 'D'), (4, 'E'), (4, 'F'), (4 , 'G'), (4, 'H'),
; (5, 'A'), (5, 'B'), (5, 'C'), (5, 'D'), (5, 'E'), (5, 'F'), (5 , 'G'), (5, 'H'),
; (6, 'A'), (6, 'B'), (6, 'C'), (6, 'D'), (6, 'E'), (6, 'F'), (6 , 'G'), (6, 'H'),
; (7, 'A'), (7, 'B'), (7, 'C'), (7, 'D'), (7, 'E'), (7, 'F'), (7 , 'G'), (7, 'H')]
Python은 다양한 멋진 인수와 키워드 인수를 지원합니다. Python에서는 다음과 같이 할 수 있습니다.
만나다:
>>> defional_arg(pos1, pos2, 키워드1=없음, 키워드2=42):
... 반환 [pos1, pos2, 키워드1, 키워드2]
...
>>> 선택사항_arg(1, 2)
[1, 2, 없음, 42]
>>> 선택사항_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> 선택사항_arg(키워드1=1, pos2=2, pos1=3, 키워드2=4)
[3, 2, 1, 4]
Hy에서도 마찬가지입니다.
=> (defn 선택사항-arg [pos1 pos2 &선택적 키워드1 [keyword2 42]]
... [pos1 pos2 키워드1 키워드2])
=> (선택적 인수 1 2)
[1 2 없음 42]
=> (선택적 인수 1 2 3 4)
[1 2 3 4]
Hy 0.10.1 이전 버전(예: git master)을 실행하고 있다면 멋진 새 버전도 있습니다.
키워드 인수 구문:
=> (선택적 인수 :keyword1 1
... :pos2 2
... :pos1 3
... :keyword2 4)
[3, 2, 1, 4]
그렇지 않으면 언제든지 사용할 수 있습니다. 대다. 그런데 뭐죠? 대다?
스쳐가는 것에 익숙하신가요? *인수 과 ** kwargs 파이썬에서?:
>>> 인수 = [1 2]
>>> kwargs = {"keyword2": 3
... "키워드1": 4}
>>> 선택사항_arg(*args, **kwargs)
우리는 이것을 다음과 같이 재현할 수 있습니다. 대다:
=> (setv 인수 [1 2])
=> (setv kwargs {"keyword2" 3
... "키워드1" 4})
=> (선택적 인수 args kwargs 적용)
[1, 2, 4, 3]
다음과 같은 사전 스타일 키워드 인수 구성도 있습니다.
(다른 스타일 정의 [&key {"key1" "val1" "key2" "val2"}]
[키1 키2])
여기서 차이점은 사전이기 때문에 특정 단어에 의존할 수 없다는 것입니다.
인수 순서를 지정합니다.
효도 응원한다 *인수 과 ** kwargs. 파이썬에서는:
def some_func(foo, bar, *args, **kwargs):
수입 인쇄물
pprint.pprint((푸, 바, 인수, kwargs))
Hy 등가물:
(some-func 정의 [foo bar &rest args &kwargs kwargs]
(인쇄물 수입)
(pprint.pprint(, foo bar args kwargs)))
마지막으로 물론 수업이 필요합니다! Python에는 다음과 같은 클래스가 있을 수 있습니다.
클래스 FooBar(객체):
"" "
또 다른 예제 클래스
"" "
def __init__(self, x):
자기.x = x
def get_x(자기):
"" "
x 사본을 반환하세요.
"" "
self.x 반환
인하이:
(FooBar [객체] 정의 클래스
"또 다른 예시 수업"
[[--초기화--
(fn [자신 x]
(setv self.xx)
; __init__에는 None이 필요하기 때문에 현재 --init--에 필요합니다.
; 이 문제가 해결되길 바랍니다 :)
없음)]
[get-x
(fn [자신]
"x 사본을 돌려주세요"
자기.x)]])
클래스 수준 속성을 수행할 수도 있습니다. 파이썬에서는:
클래스 고객(모델.모델):
이름 = 모델.CharField(max_length=255)
주소 = models.TextField()
메모 = models.TextField()
인하이:
(고객 [모델.모델] 정의
[[이름 (models.CharField :최대 길이 255})]
[주소(models.TextField)]
[참고(models.TextField)]])
Hy <-> Python interop
Hy를 가져오면 Python에서 Hy를 직접 사용할 수 있습니다!
다음을 저장하면 인사말.hy:
(defn Greeting [이름] ("hello from hy", 이름 인쇄))
그런 다음 모듈을 가져오기 전에 hy를 가져와 Python에서 직접 사용할 수 있습니다. ~ 안에
파이썬 :
수입하다
수입 인사말
Greetings.greet("푸")
Python(또는 클래스!)에서 함수를 선언하고 이를 Hy!에서 사용할 수도 있습니다.
다음을 저장하면 인사말.py 파이썬에서:
데프 인사(이름):
print("안녕하세요, %s" % (이름))
Hy에서 사용할 수 있습니다.
(수입 인사말)
(.인사말 "foo")
키워드 인수를 사용하려면 다음을 사용할 수 있습니다. 인사말.py:
def 인사말(이름, 제목="선생님"):
print("안녕하세요, %s %s" % (제목, 이름))
(수입 인사말)
(.인사말 "푸")
(.인사말 "Foo" "Darth")
(적용(.인사말) ["Foo"] {"title" "Lord"})
다음과 같이 출력됩니다.
안녕하세요, 푸 선생님
안녕하세요, 다스 푸
안녕하세요, 푸경님
유용한 팁!
Hy는 또한 "스레딩 매크로"라고 알려진 기능을 제공합니다.
클로저스. "스레딩 매크로"(다음과 같이 작성됨) ->)은 깊은 중첩을 피하기 위해 사용됩니다.
표현.
스레딩 매크로는 각 표현식을 다음 표현식의 첫 번째 인수에 삽입합니다.
장소.
고전을 살펴 보겠습니다.
(루프(인쇄(평가(읽기))))
이렇게 작성하는 대신 다음과 같이 작성할 수 있습니다.
(-> (읽기) (평가) (인쇄) (루프))
이제 사용 파이썬 쉬, (python-sh의 설정으로 인해) 스레딩 매크로가 어떻게 작동하는지 보여줄 수 있습니다.
파이프처럼 사용할 수 있습니다.
=> (가져오기 [sh [cat grep wc]])
=> (-> (cat "/usr/share/dict/words") (grep "-E" "^hy") (wc "-l"))
210
물론 다음으로 확장됩니다.
(wc (grep (cat "/usr/share/dict/words") "-E" "^hy") "-l")
훨씬 더 읽기 쉽습니다. 그렇죠? 스레딩 매크로를 사용해보세요!
HY STYLE GUIDE
“장관님, 저는 여러 면에서 덤블도어의 의견에 동의하지 않습니다…
스타일이 있어요…” — Phineas Nigellus Black, 괴롭히다 도예가 과 전에, 주문번호 of 전에, 피닉스
Hy 스타일 가이드는 Hyve(예, Hy 커뮤니티)의 기본 규칙 세트가 될 것입니다.
모든 것에 Hy를 추가하여 관용적인 Hy 코드를 작성하는 것을 자랑스럽게 생각합니다. Hy는 많이 파생됩니다
Clojure 및 Common Lisp에서 가져온 동시에 항상 Python 상호 운용성을 유지합니다.
전주곡
XNUMXD덴탈의 타오 of Hy
엄몬이 주지스님에게 “당신은 무슨 경전을 설하고 있습니까?”라고 물었습니다.
“열반경(Nirvana Sutra).”
"열반경에는 XNUMX가지 미덕이 있지 않습니까?"
"그렇습니다."
엄몬은 컵을 들고 물었다. "이게 얼마나 많은 공덕이 있습니까?"
"전혀 없습니다." 승려가 말했습니다.
"하지만 고대인들은 그런 일이 있었다고 말했죠, 그렇죠?" 어몬이 말했다.
"그들이 말한 것에 대해 어떻게 생각하세요?"
엄몬은 컵을 치며 “이해하셨나요?”라고 물었다.
"아니요." 스님이 말했습니다.
"그렇다면, 경전 강의를 계속하는 것이 좋겠습니다."라고 Ummon이 말했습니다.
— (koan) 매크로
다음은 제작에 들어간 디자인 결정의 간략한 목록을 보여줍니다.
숨바꼭질.
· Lisp처럼 보입니다. DTRT(예: 대시가 밑줄로 바뀌고 귀마개는
모두 대문자).
· 우리는 여전히 Python입니다. 대부분의 내부는 1:1로 Python 내부로 변환됩니다.
· 어디에서나 유니코드를 사용하세요.
· 가능하면 Python 2에서 잘못된 결정을 수정합니다(참조 true_division).
· 의심스러우면 Python을 사용하세요.
· 여전히 확신이 없다면 Clojure로 미루세요.
· 더 확실하지 않다면 Common Lisp를 따르세요.
· 우리는 Clojure가 아니라는 점을 명심하세요. 우리는 커먼 리스프가 아닙니다. 우리는 Homoiconic Python입니다.
의미가 있는 추가 비트.
레이아웃 & 들여 쓰기
· 후행 공백을 피하십시오. 짜증나!
· 들여쓰기는 들여쓰기와 일치하는 경우를 제외하고는 2개의 공백(하드 탭 없음)이어야 합니다.
이전 줄.
;; 좋음(바람직함)
(fib 정의 [n]
(만약 (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))
;; 그래도 괜찮아
(fib 정의 [n]
(if (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
;; 그래도 괜찮아
(fib 정의 [n]
(만약 (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))
;; 히스테리적으로 우스꽝스럽습니다
(fib 정의 [n]
(만약 (<= n 2)
N ;; 네, 저는 무작위로 스페이스 키를 누르는 걸 좋아해요
(+ (fib (- n 1)) (fib (- n 2)))))
· 괄호는 필수 못 홀로 남겨져 슬프고 외로워집니다.
;; 좋음(바람직함)
(fib 정의 [n]
(만약 (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))
;; 히스테리적으로 우스꽝스럽습니다
(fib 정의 [n]
(만약 (<= n 2)
n
(+ (fib(-n 1)) (fib(-n 2)))
)
) ; 가, 불로 태워버려
· 수직 정렬 하자 블록.
([[foo (바)]를 보자
[qux(바즈)]]
(푸 퀑))
· 인라인 주석은 코드 끝에서 두 칸 띄워야 합니다. 그들은 항상
주석 문자와 주석 시작 사이의 공백입니다. 또한 그러지 않으려고 노력하세요.
명백한 의견을 말하십시오.
;; 좋은
(setv ind (dec x)) ; 인덱싱은 0부터 시작됩니다.
;; 스타일을 준수하지만 명백한 내용만 명시합니다.
(setv ind (dec x)) ; 인덱스를 x-1로 설정합니다.
;; 나쁜
(setv ind (dec x));재미로 단어 입력하기
코딩 스타일
· 관례적으로 사용하지 마십시오. def 전역 변수 이외의 경우; 사용 세트
내부 함수, 루프 등
;; 좋음(바람직함)
(데프 *제한* 400000)
(섬유질 정의 [ab]
(사실이지만
(a를 산출하다)
(setv (, ab) (, b (+ ab)))))
;; 나쁨(바람직하지 않음)
(섬유질 정의 [ab]
(사실이지만
(a를 산출하다)
(def (, ab) (, b (+ ab)))))
· 벡터 구문을 사용하려는 곳에 s-expression 구문을 사용하지 마십시오. 예를 들어, 사실
이 두 예제 중 전자가 작동한다는 것은 컴파일러가 지나치게
엄격한. 실제로 이와 같은 곳에서 올바른 구문은 후자입니다.
;; 나쁜 (그리고 악한)
(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 (열기 "/ etc / passwd")]
(인쇄(.readlines fd)))
;; 그다지 좋지 않음
([fd (열기 "/ etc / passwd")]
(인쇄(fd.readlines)))
결론
"패션은 사라지지만 스타일은 영원하다" -Yves Saint Laurent
이 가이드는 단지 커뮤니티 가이드라인의 집합일 뿐이며, 분명히 커뮤니티 가이드라인은
활발한 커뮤니티가 없으면 말이 안 돼요. 기여를 환영합니다. #hyin 에서 함께하세요
freenode, 블로그, 트윗, 그리고 가장 중요한 것은 Hy와 함께 즐거운 시간을 보내세요.
감사
· 이 가이드는 다음에서 많은 영감을 받았습니다. @폴태그 님의 블로그 게시물 Hy 살아남기 안내서
· Clojure 스타일 안내서
사용 설명서 INDEX
내용 :
명령 라인 인터페이스
hy
명령 라인 옵션
-c
Hy 코드를 실행합니다. 명령.
$ hy -c "(인쇄 (+ 2 2))"
4
-i
Hy 코드를 실행합니다. 명령, REPL에 머물러 있습니다.
-m
Hy 코드를 실행합니다. 모듈를 포함한 정의 정의된 경우.
XNUMXD덴탈의 -m 플래그는 옵션 목록을 종료하여 이후의 모든 인수가 모듈 name
모듈에 전달됩니다. sys.argv.
버전 0.10.2의 새로운 기능.
--스파이 실행하기 전에 동등한 Python 코드를 인쇄하십시오. 예를 들어:
=> (defn salutationsnm [이름] (인쇄 (+ "Hy " 이름 "!")))
def 인사말nm(이름):
return print(((u'Hy ' + 이름) + u'!'))
=> (인사말 "귀하의 이름")
salutationsnm(u'YourName')
하이 유어네임!
=>
버전 0.9.11의 새로운 기능.
--쇼-추적
Hy 예외에 대한 확장 역추적을 인쇄합니다.
버전 0.9.12의 새로운 기능.
-v Hy 버전 번호를 인쇄하고 종료합니다.
안녕
명령 라인 옵션
파일[, 파일N]
Hy 코드를 Python 바이트코드로 컴파일합니다. 예를 들어 다음 코드를 다음과 같이 저장합니다.
하이네임.hy:
(hy-hy [이름] 정의
(인쇄(+ "Hy" 이름 "!")))
(hy-hy "아프로맨")
그런 다음 다음을 실행하십시오.
$ hyc hyname.hy
$ 파이썬 하이네임.pyc
안녕 아프로맨!
hy2py
버전 0.10.1의 새로운 기능.
명령 라인 옵션
-s
--소스 포함
구문 분석된 소스 구조를 표시합니다.
-a
--with-ast
생성된 AST를 표시합니다.
-np
--파이썬 없이
AST에서 생성된 Python 코드를 표시하지 않습니다.
Hy ( 언어)
경고 :
이것은 불완전합니다. 문서화 노력에 기여하는 것을 고려해 보십시오.
이론 of Hy
Hy는 무엇보다도 Python과 양방향으로 100% 호환성을 유지합니다.
그 자체. 모든 Hy 코드는 몇 가지 간단한 규칙을 따릅니다. 나올 예정이니 꼭 기억해두세요
능숙한.
이러한 규칙은 Hy 코드가 두 언어 모두에서 관용적이고 인터페이스 가능하도록 보장하는 데 도움이 됩니다.
· Earmufs의 기호는 해당 문자열의 대문자 버전으로 변환됩니다. 을 위한
예, 푸 될 것입니다 FOO.
· UTF-8 엔터티는 다음을 사용하여 인코딩됩니다. 퓨니 코드 그리고 접두사가 붙은 hy_. 예를 들어, ⚘
될 것입니다 hy_w7h, ♥ 될 것입니다 hy_g6h및 나♥너 될 것입니다 hy_iu_t0x.
· 대시가 포함된 기호는 밑줄로 대체됩니다. 예를 들어,
렌더 템플릿 될 것입니다 렌더링 템플릿. 즉, 대시가 있는 기호는
밑줄에 해당하는 부분을 숨기고 그 반대의 경우도 마찬가지입니다.
내장
Hy에는 올바른 Python AST를 생성하는 데 사용되는 여러 가지 특수 형식이 있습니다.
다음은 "특수" 형식으로, 약간 예상치 못한 동작이 있을 수 있습니다.
어떤 상황.
.
버전 0.10.0의 새로운 기능.
. 객체에 대한 속성 액세스를 수행하는 데 사용됩니다. 빠른 속도를 허용하기 위해 작은 DSL을 사용합니다.
중첩된 데이터 구조의 속성 및 항목에 액세스합니다.
예를 들어,
(.foo 바 baz [(+ 1 2)] 프롭)
다음으로 컴파일됩니다.
foo.bar.baz[1 + 2].frob
. 첫 번째 인수를 컴파일합니다(예제에서는 푸)를 수행할 개체로
속성 역참조. 이는 액세스할 속성으로 기본 기호를 사용합니다(예제에서는 바,
바즈, 물건을 빼앗다), 목록의 내용을 컴파일합니다(예제에서는 [(+ 1 2)]) 인덱싱을 위해.
다른 인수에서는 컴파일 오류가 발생합니다.
알 수 없는 속성에 액세스하면 속성 오류. 알 수 없는 키에 접근하면 오류가 발생합니다.
인덱스 오류 (리스트와 튜플에서) 또는 키 오류 (사전에서).
->
-> (또는 스레딩 매크로)은 표현식의 중첩을 방지하는 데 사용됩니다. 스레딩 매크로
각 표현식을 다음 표현식의 첫 번째 인수 위치에 삽입합니다. 다음과 같은
코드는 다음을 보여줍니다.
=> (defn 출력 [ab] (인쇄 ab))
=> (-> (+ 4 6) (출력 5))
10 5
->>
->> (또는 스레딩 꼬리 매크로) 와 비슷하다 스레딩 매크로, 대신
각 표현식을 다음 표현식의 첫 번째 인수에 삽입하면 이를 다음 표현식의 첫 번째 인수로 추가합니다.
마지막 논쟁. 다음 코드는 이를 보여줍니다.
=> (defn 출력 [ab] (인쇄 ab))
=> (->> (+ 4 6) (출력 5))
5 10
대다
대다 선택적 인수 목록과 선택적 kwargs 사전을 적용하는 데 사용됩니다.
기능에.
용법: (적용하다 fn-이름 [인수] [크와르그])
예 :
(defn 썽크 []
"안녕하세요")
(썽크 적용)
;=> "안녕하세요"
(총 구매 정의 [가격 금액 및 옵션 [수수료 1.05] [부가가치세 1.1]]
(* 가격 금액 수수료 부가세))
(총구매[10 15] 적용)
;=> 173.25
(총 구매액 [10 15] {"vat" 1.05} 적용)
;=> 165.375
(총구매액[] {"가격" 10 "금액" 15 "부가가치세" 1.05} 적용)
;=> 165.375
과
과 논리식에 사용됩니다. 최소한 두 개의 매개변수가 필요합니다. 모든 매개변수의 경우
평가하다 참된, 마지막 매개변수가 반환됩니다. 그 외의 경우에는 첫 번째 거짓 값
반환됩니다. 사용 예:
=> (그리고 참 거짓)
거짓
=> (그리고 참 참)
참된
=> (그리고 참 1)
1
=> (그리고 참 [] 거짓 참)
[]
알림:
과 첫 번째 거짓이 발생하는 즉시 단락을 일으키고 매개변수 평가를 중지합니다.
만났다.
=> (및 False("hello" 인쇄))
거짓
단언하다
단언하다 프로그램이 실행되는 동안 조건을 확인하는 데 사용됩니다. 조건이 안되면
만났다, 어설션오류 제기됩니다. 단언하다 하나 또는 두 개의 매개변수를 사용할 수 있습니다. 첫번째
매개변수는 확인할 조건이며 다음 중 하나로 평가되어야 합니다. 참된 or 거짓. 그만큼
선택적인 두 번째 매개변수는 Assert의 레이블이며,
으로 제기된 어설션오류. 예를 들면 :
(어설션(=변수 기대값))
(거짓 주장)
; 어설션오류
(주장 (= 1 2) "하나는 XNUMX와 같아야 한다")
; AssertionError: 하나는 XNUMX와 같아야 합니다
ASSOC
ASSOC 키를 사전의 값과 연관시키거나 목록의 색인을 설정하는 데 사용됩니다.
값으로. 최소한 세 가지 매개변수가 필요합니다. 데이터 구조 수정될 키
or 색인및 가치. XNUMX개 이상의 매개변수를 사용하는 경우 쌍으로 연결됩니다.
사용 예 :
=>([[컬렉션 {}]]
... (소속 컬렉션 "Dog" "Bark")
... (인쇄물 컬렉션))
{u'개': u'짖는다'}
=>([[컬렉션 {}]]
... (소속 컬렉션 "개" "짖음" "고양이" "야옹")
... (인쇄물 컬렉션))
{u'Cat': u'야옹', u'Dog': u'짖음'}
=>([[컬렉션 [1 2 3 4]]]
...(연관 컬렉션 2 없음)
... (인쇄물 컬렉션))
[1, 2, 없음, 4]
알림:
ASSOC 현재 위치의 데이터 구조를 수정하고 반환합니다. 없음.
하다
하다 루프를 벗어나는 데 사용됩니다. 루프를 즉시 종료합니다. 다음과 같은
예는 무한하다 동안 사용자가 입력하자마자 종료되는 루프 k.
(True(if (= "k" (원시 입력 "? ")))
(부서지다)
("다시 시도" 인쇄)))
조건
조건 중첩된 빌드에 사용할 수 있음 if 진술. 다음 예에서는
매크로와 확장 간의 관계:
(조건 [조건-1 결과-1]
[조건-2 결과-2])
(조건-1 결과-1인 경우)
(조건-2 결과-2인 경우))
아래와 같이 첫 번째로 일치하는 결과 블록만 실행됩니다.
=> (검사 값 [값] 정의
... (cond [(< 값 5) (인쇄 "값이 5보다 작습니다")]
... [(= 값 5) ("값은 5와 같습니다" 인쇄)]
... [(> 값 5) ("값이 5보다 큼" 인쇄)]
... [참("값은 있어서는 안되는 값입니다" 인쇄)]))
=> (검사값 6)
값이 5보다 큼
계속
계속 실행을 루프 시작으로 반환합니다. 다음 예에서는
(부작용1) 각 반복마다 호출됩니다. (부작용2)그러나 은(는) 호출됩니다.
목록의 다른 모든 값.
;; (side- effect1)과 (side- effect2)가 함수이고
;; 컬렉션은 숫자 값의 목록입니다.
([x 컬렉션]의 경우
(정당한
(부작용1 x)
(만약 (% x 2)
(계속하다))
(부작용2 x)))
dict-comp
dict-comp 사전을 생성하는 데 사용됩니다. XNUMX~XNUMX개의 매개변수가 필요합니다. 첫번째
두 개의 매개변수는 반환 값(키-값 쌍)을 제어하기 위한 것이고 세 번째 매개변수는
시퀀스에서 항목을 선택하는 데 사용됩니다. 네 번째이자 선택적 매개변수는 다음과 같이 사용할 수 있습니다.
조건식을 기반으로 시퀀스의 일부 항목을 필터링합니다.
=> (dict-comp x (* x 2) [x (범위 10)] (홀수? x))
{1:2, 3:6, 9:18, 5:10, 7:14}
do / 예측
do 과 예측 각 인수를 평가하고 마지막 인수를 반환하는 데 사용됩니다. 반품
마지막 인수를 제외한 모든 인수의 값은 삭제됩니다. 그것은에서 사용될 수 있습니다 람다 or
목록 구성 요소 다음 예 중 하나에 표시된 것처럼 더 복잡한 논리를 수행합니다.
몇 가지 사용 예:
=> (사실이라면
... (do ("Side effect rock!" 인쇄)
... ("그래, 정말이야!" 인쇄)))
부작용이 심해요!
그래 진짜!
;; (부작용)이 각각에 대해 호출하려는 함수라고 가정합니다.
;; 목록에 있는 모든 값이지만 그 반환 값은 우리가 신경 쓰지 않습니다.
=> (list-comp (do (부작용 x)
... (if (< x 5) (* 2 x)
... (* 4 x)))
... (x (범위 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]
do 1부터 n까지 임의 개수의 인수를 허용할 수 있습니다.
def / 세트
def 과 세트 값, 개체 또는 기능을 기호에 바인딩하는 데 사용됩니다. 예를 들어:
=> (def 이름 ["Alice" "Bob" "Charlie"])
=> (정자체 이름)
[u'앨리스', u'밥', u'찰리']
=> (setv 카운터(fn [수집 항목] (.count 수집 항목)))
=> (카운터 [1 2 3 4 5 2 3] 2)
2
분류를 해제하다
새로운 클래스는 다음과 같이 선언됩니다. 분류를 해제하다. 두 개의 선택적 매개변수(벡터)를 사용할 수 있습니다.
가능한 슈퍼 클래스와 새로운 클래스의 속성을 포함하는 또 다른 벡터를 정의합니다.
클래스를 두 개의 항목 벡터로 분류합니다.
(defclass 클래스 이름 [슈퍼클래스-1 슈퍼클래스-2]
[[속성 값]])
아래 예제와 같이 값과 함수 모두 새 클래스에 바인딩될 수 있습니다.
=> (Cat [] 클래스 정의
... [[나이 없음]
... [색상 "흰색"]
... [말하기 (fn [self] ("야옹" 인쇄))]])
=> (방어 지점(고양이))
=> (setv spot.colour "검은색")
'검은색'
=> (.말하기 지점)
야옹
데프 / 반박하다
데프 과 반박하다 매크로는 기능을 정의하는 데 사용됩니다. 그들은 세 가지 매개변수를 취합니다: name
정의할 함수의 벡터 매개 변수및 몸 기능:
(이름 [params] 본문 정의)
매개변수 앞에는 다음과 같은 키워드가 있을 수 있습니다.
&선택 과목
매개변수는 선택사항입니다. 매개변수는 두 개의 항목 목록으로 제공될 수 있습니다.
첫 번째 요소는 매개변수 이름이고 두 번째 요소는 기본값입니다. 매개변수
단일 항목으로 제공할 수도 있으며, 이 경우 기본값은 다음과 같습니다. 없음.
=> (총 가치 정의 [값 및 선택 사항 [부가가치세 10]]
... (+ (/ (* 값 부가가치세) 100) 값))
=> (총액 100)
110.0
=> (총액 100 1)
101.0
&열쇠
&kwargs
매개변수에는 0개 이상의 키워드 인수가 포함됩니다.
다음 코드 예제는 모든 키워드를 인쇄하는 함수를 정의합니다.
인수와 그 값.
=> (인쇄 매개변수 정의 [&kwargs kwargs]
... ([(, kv) (.items kwargs)] (kv 인쇄)))
=> (인쇄 매개변수 [] {"매개변수-1" 1 "매개변수-2" 2} 적용)
매개변수-2 2
매개변수-1 1
&나머지 매개변수에는 0개 이상의 위치 인수가 포함됩니다. 다른 위치 없음
인수는 이 인수 뒤에 지정될 수 있습니다.
다음 코드 예제에서는 0부터 n까지의 숫자를 지정할 수 있는 함수를 정의합니다.
매개변수. 그런 다음 모든 홀수를 합산하고 모든 짝수를 뺍니다.
=> (지그재그 합 정의 [&나머지 숫자]
([[홀수 (list-comp x [x 숫자] (홀수? x))]
[짝수(list-comp x [x 숫자] (짝수? x))]]
(- (홀수 합) (짝수 합))))
=> (지그재그 합)
0
=> (지그재그 합 3 9 4)
8
=> (지그재그 합 1 2 3 4 5 6)
-3
정의 별칭 / defun 별칭
버전 0.10.0의 새로운 기능.
XNUMXD덴탈의 정의 별칭 과 defun 별칭 매크로는 거의 비슷해요 데프, 다음과 같은 차이점이 있습니다.
단일 이름으로 함수를 정의하는 대신 별칭을 정의할 수도 있습니다. 다른
함수 이름에 대한 기호 목록을 첫 번째 매개변수로 사용하는 것보다 정의 별칭 과
defun 별칭 와 다르지 않다 데프 과 반박하다.
=> (defn-alias [기본 이름 별칭] []
... ("안녕하세요!" 인쇄))
=> (주 이름)
"안녕하세요!"
=> (별칭)
"안녕하세요!"
정의
버전 0.10.1의 새로운 기능.
XNUMXD덴탈의 정의 매크로는 다음과 같이 즉시 호출되는 기본 함수를 정의합니다. sys.argv as
이 파일이 스크립트로 실행되는 경우에만 인수입니다. 즉, 이는 다음과 같습니다.
(defmain [&rest 인수]
(인수로 뭔가를 함))
다음과 같습니다:
def 메인(*args):
do_something_with(인수)
0를 반환
__name__ == "__main__"인 경우:
import sys
retval = 메인(*sys.arg)
isinstance(retval, int)인 경우:
sys.exit(복귀)
위에서 볼 수 있듯이 이 함수에서 정수를 반환하면 다음과 같습니다.
스크립트의 종료 상태로 사용됩니다. (Python의 기본 종료 상태는 0입니다. 그렇지 않으면,
이는 모든 것이 괜찮다는 뜻입니다!)
(부터 (sys.exit 0) 정수가 아닌 반환의 경우 명시적으로 실행되지 않습니다.
정의, 넣는 것이 좋습니다 (정의) 파일의 마지막 코드 부분으로 사용하세요.)
def매크로
def매크로 매크로를 정의하는 데 사용됩니다. 일반적인 형식은 다음과 같습니다. (def매크로 name [매개변수]
특급).
다음 예에서는 코드의 요소 순서를 바꾸는 데 사용할 수 있는 매크로를 정의합니다.
사용자는 중위 표기법으로 코드를 작성할 수 있습니다. 여기서 연산자는
피연산자.
=> (defmacro infix [코드]
... (준따옴표(
... (인용 해제(코드 1 가져오기))
... (인용 해제(코드 0 가져오기))
... (인용 해제(코드 2 가져오기)))))
=> (중위 (1 + 1))
2
defmacro-alias
defmacro-alias 여러 이름(별칭)으로 매크로를 정의하는 데 사용됩니다. 일반적인 형식
is (def매크로 별칭 [이름] [매개변수] 특급). 동일한 매크로를 여러 개 생성합니다.
지정된 이름 목록 아래의 매개변수 목록 및 본문.
다음 예에서는 사용자가 코드를 작성할 수 있도록 하는 두 개의 매크로를 정의합니다.
중위 표기법.
=> (defmacro-alias [중위 infi] [코드]
... (준따옴표(
... (인용 해제(코드 1 가져오기))
... (인용 해제(코드 0 가져오기))
... (인용 해제(코드 2 가져오기)))))
=> (중위 (1 + 1))
2
=> (인파이(1 + 1))
2
defmacro/g!
버전 0.9.12의 새로운 기능.
defmacro/g! 의 특별 버전입니다 def매크로 자동으로 생성하는 데 사용되는 젠심
다음으로 시작하는 모든 기호에 대해 g!.
예를 들어, 가!아 될 것이다 (겐심 "ㅏ").
만나다 또한:
섹션 using-gensym
디프리더
버전 0.9.12의 새로운 기능.
디프리더 판독기 매크로를 정의하여 구문을 재구성하거나 수정할 수 있습니다.
=> (defreader ^ [expr] (인쇄 expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"안녕하세요"
"여보세요"
만나다 또한:
섹션 리더 매크로
델
버전 0.9.12의 새로운 기능.
델 현재 네임스페이스에서 개체를 제거합니다.
=> (setv foo 42)
=> (델 푸)
=> 푸
추적 (최근 호출 마지막) :
파일 " ", 라인 1, in
NameError: 이름 'foo'가 정의되지 않았습니다.
델 매핑, 목록 등에서 개체를 제거할 수도 있습니다.
=> (setv 테스트(목록(범위 10)))
=> 테스트
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (슬라이스 테스트 2 4)) ;; 제외된 항목을 2~4개에서 제거하세요.
=> 테스트
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> 딕
{"foo": "바"}
=> (del (dic "foo" 가져오기))
=> 딕
{}
도토
버전 0.10.1의 새로운 기능.
도토 객체에 대한 일련의 메소드 호출을 단순화하는 데 사용됩니다.
=> (doto [] (.append 1) (.append 2) .reverse)
[2 1]
=> (setv 컬렉션 [])
=> (.append 컬렉션 1)
=> (.append 컬렉션 2)
=> (.reverse 컬렉션)
=> 수집
[2 1]
평가
평가 인용된 표현식을 평가하고 값을 반환합니다.
=> (eval '("Hello World" 인쇄))
"안녕하세요 세계"
평가 및 컴파일
컴파일 시 평가
먼저 / 자동차
먼저 과 자동차 컬렉션의 첫 번째 요소에 액세스하기 위한 매크로입니다.
=> (첫 번째(범위 10))
0
for
for 목록이나 벡터의 각 요소에 대한 함수를 호출하는 데 사용됩니다. 각각의 결과
통화는 폐기되고 for 표현식 반환 없음 대신에. 예제 코드는 반복됩니다.
위에 수집 그리고 각각 요소 in 수집 전화 부작용 기능
요소 인수로 :
;; (부작용)이 단일 매개변수를 취하는 함수라고 가정합니다.
([요소 컬렉션]의 경우(부작용 요소))
;; for에는 선택적 else 블록이 있을 수 있습니다.
([요소 컬렉션]의 경우(부작용 요소)
(그밖에 (부작용-2)))
선택적 그렇지 않으면 블록은 다음과 같은 경우에만 실행됩니다. for 루프가 정상적으로 종료됩니다. 만약
으로 처형이 정지된다 하다Walk Through California 프로그램, 그렇지 않으면 블록이 실행되지 않습니다.
=> ([요소 [1 2 3]]의 경우 (if (< 요소 3)
... (인쇄 요소)
... (부서지다))
... (else ("루프 완료" 인쇄)))
1
2
=> ([요소 [1 2 3]]의 경우 (if (< 요소 4)
... (인쇄 요소)
... (부서지다))
... (else ("루프 완료" 인쇄)))
1
2
3
루프 완료
유전자xpr
유전자xpr 생성기 표현식을 만드는 데 사용됩니다. 두 개 또는 세 개의 매개변수가 필요합니다. 그만큼
첫 번째 매개변수는 반환 값을 제어하는 표현식이고, 두 번째 매개변수는 사용됩니다.
목록에서 항목을 선택합니다. 세 번째이자 선택적 매개변수를 사용하여 필터링할 수 있습니다.
조건식을 기반으로 하는 목록의 일부 항목입니다. 유전자xpr 와 유사하다
목록 구성 요소단, 값을 하나씩 평가하는 반복 가능 항목을 반환한다는 점은 제외됩니다.
즉시 평가합니다.
=> (def 컬렉션(범위 10))
=> (def 필터링됨 (geneexpr x [x 컬렉션] (심지어? x)))
=> (목록이 필터링됨)
[0]
젠심
버전 0.9.12의 새로운 기능.
젠심 없이 매크로를 작성할 수 있는 고유한 기호를 생성하는 데 사용됩니다.
실수로 변수 이름이 충돌했습니다.
=> (젠심)
u':G_1235'
=> (gensym "x")
u':x_1236'
만나다 또한:
섹션 using-gensym
얻을
얻을 목록과 사전의 단일 요소에 액세스하는 데 사용됩니다. 얻을 두 가지 매개변수를 취합니다:
전에, 데이터 구조 그리고 색인 or 키 항목의. 그런 다음 해당 항목을 반환합니다.
사전이나 목록의 값입니다. 사용 예:
=> ([[동물 {"개" "짖음" "고양이" "야옹"}]
... [숫자 ["XNUMX" "XNUMX" "XNUMX" "XNUMX"]]]
... (인쇄(동물 "개" 가져오기))
... (인쇄(숫자 2 가져오기)))
나무 껍질
두
알림:
얻을 존재하지 않는 키에 대해 사전을 쿼리하면 KeyError가 발생합니다.
알림:
얻을 목록 또는 튜플에서 범위를 벗어난 인덱스에 대해 쿼리하면 IndexError가 발생합니다.
범위.
글로벌
글로벌 기호를 전역으로 표시하는 데 사용할 수 있습니다. 이를 통해 프로그래머는
값을 전역 기호로 변환합니다. 전역 기호를 읽는 데에는 다음이 필요하지 않습니다. 글로벌 키워드 --
할당만 하면 됩니다.
다음 예에서는 전역 기호가 어떻게 사용되는지 보여줍니다. a 함수에 값이 할당되고
나중에 다른 기능으로 인쇄됩니다. 없이 글로벌 키워드, 두 번째 함수
던졌을 것이다 이름 오류.
(정의 set-a [값]
(글로벌 a)
(값을 설정))
(defn 인쇄-a []
(인쇄 a))
(세트 5)
(인쇄)
if / 그렇지 않다면
버전 0.10.0의 새로운 기능: if-not
if 실행할 코드를 조건부로 선택하는 데 사용됩니다. 조건이 포함되어 있어야 합니다.
블록 및 조건 블록이 다음과 같이 평가될 경우 실행될 블록 참된. 선택적으로,
조건 평가가 다음과 같은 경우 실행되는 최종 블록을 포함할 수 있습니다.
거짓.
그렇지 않다면 비슷하지만 조건이 실패하면 두 번째 블록이 실행됩니다.
테스트가 성공하면 세 번째이자 마지막 블록이 실행됩니다. 즉, 반대 순서입니다. if.
사용 예 :
(if (돈이 남았나요? 계좌)
("쇼핑하러 가자" 인쇄)
("가서 일하자" 인쇄))
(만약-그렇지 않다면 (돈이 남나요? 계좌)
("가서 일하자"라고 인쇄하세요)
("쇼핑하러 가자" 인쇄))
파이썬의 진실성은 존중됩니다. 없음, 거짓, 숫자 유형의 XNUMX, 빈 시퀀스,
빈 사전이 고려됩니다. 거짓; 다른 모든 것이 고려됩니다 참된.
리스프-이프 / 난생 과 리스프-이-프-아니 / 생명이 없는
버전 0.10.0의 새로운 기능.
버전 0.10.2의 새로운 기능: lisp-if-not / lif-not
더 Lispy를 선호하는 사람들을 위해 if 조항, 우리는 리스프-이프및 난생. 이 만 고려하다
없음 / 무 거짓이다! 다른 모든 "거짓 같은" Python 값은 참으로 간주됩니다.
반대로, 우리는 리스프-이-프-아니 과 생명이 없는 병행하여 if 과 그렇지 않다면 반전
비교.
=> (lisp-if True "true" "false")
"진실"
=> (lisp-if False "true" "false")
"진실"
=> (lisp-if 0 "true" "false")
"진실"
=> (lisp-nil이 "true" "false"인 경우)
"거짓"
=> (lisp-if None "true" "false")
"거짓"
=> (lisp-if-not nil "true" "false")
"진실"
=> (lisp-if-not None "true" "false")
"진실"
=> (lisp-if-not False "true" "false")
"거짓"
; 동일하지만 더 짧음
=> (lif True "true" "false")
"진실"
=> (lif nil "true" "false")
"거짓"
=> (lif-not None "true" "false")
"진실"
import
import Python처럼 모듈을 가져오는 데 사용됩니다. 여러 가지 방법이 있습니다. import
사용하십시오.
;; 이러한 각 모듈을 가져옵니다.
;;
;; 파이썬:
;; 수입 시스템
;; os.path 가져오기
(sys os.path 가져오기)
;; 모듈에서 가져오기
;;
;; Python: os.path에서 가져오기가 존재함, isdir, isfile
(가져오기 [os.path [exists isdir isfile]])
;; 별칭으로 가져오기
;;
;; Python: sys를 systest로 가져오기
(가져오기 [sys :as systest])
;; 다양한 유형의 가져오기를 원하는 만큼 나열할 수 있습니다.
(가져오기 [tests.resources [kwtest 함수-대시]]
[os.path [isdir isfile이 존재함]]
[sys :as systest])
;; 모든 모듈 함수를 현재 네임스페이스로 가져오기
(가져오기 [sys [*]])
람다 / fn
람다 과 fn 익명 함수를 정의하는 데 사용할 수 있습니다. 매개변수는 다음과 유사합니다.
데프: 첫 번째 매개변수는 매개변수의 벡터이고 나머지는 매개변수의 본문입니다.
기능. 람다 새로운 함수를 반환합니다. 다음 예에서는 익명 함수
정의되어 출력 필터링을 위해 다른 함수로 전달됩니다.
=> (def people [{:name "Alice" :age 20}
... {:이름 "밥" :나이 25}
... {:이름 "찰리" :나이 50}
... {:이름 "데이브" :나이 5}])
=> (표시-사람 정의 [사람 필터]
... ([사람 사람]의 경우 (if (사람 필터링) (인쇄 (:이름 사람)))))
=> (표시-사람 명 (fn [사람] (< (:나이 사람) 25)))
앨리스
데이브
일반 함수 정의와 마찬가지로 본문의 첫 번째 요소가 문자열이면
독스트링 역할을 합니다. 이는 클래스 메소드에 독스트링을 제공하는 데 유용합니다.
=> (setv XNUMX번
... (fn [x]
... "입력에 XNUMX을 곱하고 결과를 반환합니다."
... (* x 3)))
이는 Python 내장을 통해 확인할 수 있습니다. 도움 기능:
=> (도움말 XNUMX번)
times_XNUMX 함수에 대한 도움말:
회_세(x)
입력에 XNUMX을 곱하고 결과를 반환합니다.
(종료)
지난
버전 0.10.2의 새로운 기능.
지난 컬렉션의 마지막 요소에 액세스하는 데 사용할 수 있습니다.
=> (마지막 [2 4 6])
6
하자
하자 어휘 범위 변수를 생성하는 데 사용됩니다. 그들은 시작 부분에 생성됩니다.
하자 형태를 이루고 형태 이후에 존재하지 않게 된다. 다음 예에서는 이를 보여줍니다.
행동:
=> ([[x 5]] (x를 인쇄)
... ([[x 6]] (x를 인쇄))
... (x 인쇄))
5
6
5
XNUMXD덴탈의 하자 매크로는 두 개의 매개변수를 취합니다: 벡터 정의 변수 그리고 몸 어느 것이 얻는가
실행. 변수 각 요소가 단일 변수이거나 벡터인 벡터입니다.
변수 값 쌍을 정의합니다. 단일 변수의 경우 값이 할당됩니다.
없음; 그렇지 않으면 제공된 값이 사용됩니다.
=> ([x [y 5]] (xy를 인쇄))
없음 5
목록 구성 요소
목록 구성 요소 목록 이해를 수행합니다. 두 개 또는 세 개의 매개변수가 필요합니다. 첫번째
매개변수는 반환 값을 제어하는 표현식이고, 두 번째 매개변수는
목록에서 항목을 선택합니다. 세 번째이자 선택적 매개변수는 일부를 필터링하는 데 사용할 수 있습니다.
조건식을 기반으로 목록의 항목을 검색합니다. 몇 가지 예:
=> (def 컬렉션(범위 10))
=> (목록 구성 요소 x [x 컬렉션])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (list-comp (* x 2) [x 컬렉션])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
=> (list-comp (* x 2) [x 컬렉션] (< x 5))
[0]
지원
지원 논리식에 사용됩니다. 단일 매개변수를 취하고 반대의 매개변수를 반환합니다.
진실값. 만약에 참된 매개변수로 주어지며, 거짓 반환되며 그 반대도 마찬가지입니다.
사용 예 :
=> (사실이 아님)
거짓
=> (거짓 아님)
참된
=> (없음 아님)
참된
or
or 논리식에 사용됩니다. 최소한 두 개의 매개변수가 필요합니다. 그것은 반환합니다
false가 아닌 첫 번째 매개변수입니다. 해당 값이 없으면 마지막 매개변수가 반환됩니다.
=> (또는 참 거짓)
참된
=> (그리고 거짓 거짓)
거짓
=> (그리고 거짓 1 참 거짓)
1
알림:
or 첫 번째 참값이 나오자마자 단락을 일으키고 매개변수 평가를 중지합니다.
만났다.
=> (또는 True("hello" 인쇄))
참된
인쇄
인쇄 화면에 출력하는데 사용됩니다. 사용 예:
("Hello world!" 인쇄)
알림:
인쇄 항상 반환 없음.
준따옴표
준따옴표 양식을 인용할 수 있을 뿐만 아니라 표현식을 선택적으로 평가할 수도 있습니다.
내부 표현식 준따옴표 다음을 사용하여 선택적으로 평가할 수 있습니다. 인용 부호를 붙이지 않는다 (~).
평가된 형식은 다음을 사용하여 연결될 수도 있습니다. 인용 부호 해제 (~@). Quasiquote도 가능합니다.
역따옴표(`) 기호.
;; `qux'를 값이 있는 변수로 둡니다(bar baz)
`(foo ~qux)
; '(foo (bar baz))와 동일
`(foo ~@qux)
; '(foo bar baz)와 동일
견적을 원하시면, 오늘 Kevin Lee Company 에 연락주세요.
견적을 원하시면, 오늘 Kevin Lee Company 에 연락주세요. 전달된 양식을 평가하지 않고 반환합니다. 견적을 원하시면, 오늘 Kevin Lee Company 에 연락주세요. 대안적으로 될 수 있다
아포스트로피(') 기호.
=> (setv x '("Hello World" 인쇄))
; 변수 x는 표현식으로 설정되고 평가되지 않습니다.
=> 엑스
(u'print' u'Hello World')
=> (평가 x)
안녕하세요
필요
필요 특정 모듈에서 매크로를 가져오는 데 사용됩니다. 최소한 하나의 매개변수가 필요합니다.
매크로를 가져와야 하는 모듈을 지정합니다. 여러 모듈을 가져올 수 있습니다.
싱글로 필요.
다음 예에서는 다음에서 매크로를 가져옵니다. 모듈-1 과 모듈-2:
(모듈-1 모듈-2 필요)
휴식 / cdr
휴식 과 cdr 첫 번째 요소 없이 인수로 전달된 컬렉션을 반환합니다.
=> (나머지 (범위 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
세트 구성
세트 구성 세트를 만드는 데 사용됩니다. 두 개 또는 세 개의 매개변수가 필요합니다. 첫 번째 매개변수는
반환 값을 제어하기 위해 두 번째는 항목을 선택하는 데 사용됩니다.
순서. 세 번째이자 선택적 매개변수는 다음 항목 중 일부를 필터링하는 데 사용할 수 있습니다.
조건식을 기반으로 한 시퀀스입니다.
=> (setv 데이터 [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x 데이터] (홀수? x))
{1, 3, 5}
일부분
일부분 목록의 하위 집합을 가져와서 새 목록을 만드는 데 사용할 수 있습니다. 형태
분할할 목록을 지정하는 매개변수를 하나 이상 사용합니다. 두 개의 선택적 매개변수는 다음과 같습니다.
하위 집합의 시작 및 끝 위치를 제공하는 데 사용됩니다. 공급되지 않은 경우,
기본값 없음 대신 사용됩니다. 세 번째 선택적 매개변수는 다음과 같이 사용됩니다.
요소 사이의 제어 단계.
일부분 Python과 동일한 규칙을 따릅니다. 음수 인덱스가 계산됩니다.
목록의 끝부터 시작합니다. 몇 가지 사용 예:
=> (def 컬렉션(범위 10))
=> (슬라이스 컬렉션)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (슬라이스 컬렉션 5)
[5]
=> (슬라이스 컬렉션 2 8)
[2, 3, 4, 5, 6
=> (슬라이스 컬렉션 2 8 2)
[2, 4, 6]
=> (슬라이스 수집 -4 -2)
[6, 7]
던져 / 모집
XNUMXD덴탈의 던져 or 모집 양식을 사용하여 예외 런타임에. 사용 예:
(던지다)
; 마지막 예외를 다시 삭제하세요.
(IOError 발생)
; IOError 발생
(던지기(IOError "foobar"))
; IOError("foobar")를 발생시킵니다.
던져 단일 인수를 허용할 수 있습니다( 예외 클래스 또는 인스턴스) 또는 인수 없음
마지막을 다시 레이즈 예외.
시도
XNUMXD덴탈의 시도 양식은 시작하는 데 사용됩니다. 시도 / 따라 차단하다. 양식은 다음과 같이 사용됩니다.
(시험
(오류가 발생하기 쉬운 기능)
([e ZeroDivisionError] 잡기("XNUMX으로 나누기" 인쇄))
(그렇지 않으면("오류 없음" 인쇄))
(마지막으로 ("모두 완료"를 인쇄)))
시도 하나 이상 포함해야 합니다. 따라 블록이며 선택적으로 다음을 포함할 수 있습니다. 그렇지 않으면 or 최종적으로
차단하다. 실행 중에 일치하는 catch 블록으로 인해 오류가 발생하는 경우
오류가 발생하기 쉬운 기능그 따라 블록이 실행됩니다. 오류가 발생하지 않으면 그렇지 않으면
블록이 실행됩니다. 그만큼 최종적으로 블록은 실행 여부에 관계없이 마지막으로 실행됩니다.
오류가 발생했습니다.
...을 제외하면
XNUMXD덴탈의 ...을 제외하면 매크로는 작성을 위한 약어입니다. if 주어진 값인지 확인하는 명령문
조건부는 거짓. 다음은 이 매크로의 확장을 보여줍니다.
(조건문이 아닌 경우)
(조건부라면
없음
(do 진술))
인용 부호를 붙이지 않는다
준인용 형식 내에서, 인용 부호를 붙이지 않는다 기호의 평가를 강제합니다. 인용 부호를 붙이지 않는다 별칭은 다음과 같습니다.
물결표 (~) 기호.
(정의 이름 "커들스")
(준따옴표(= 이름(따옴표 해제 이름)))
;=> (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 (open "NEWS")]] (인쇄 (.read f)))
데코레이터 포함
데코레이터 포함 함수를 다른 함수로 래핑하는 데 사용됩니다. 수행하는 기능은
장식은 단일 값, 즉 장식되는 함수를 허용하고 새 값을 반환해야 합니다.
기능. 데코레이터 포함 최소 두 개의 매개변수를 사용합니다.
장식 및 장식되는 기능. 둘 이상의 데코레이터 함수가 가능합니다.
적용된; 즉, 가장 바깥쪽부터 안쪽까지 순서대로 적용됩니다. 첫번째
데코레이터는 가장 바깥쪽이 될 것입니다. 인수가 있는 데코레이터는 그냥 호출됩니다.
함수 호출처럼요.
(데코레이터 데코레이터-재미
(일부 기능 [] 정의 ...)
(데코레이터 데코레이터1 데코레이터2 ...
(일부 기능 [] 정의 ...)
(데코레이터 포함(데코레이터 인수) ..
(일부 기능 [] 정의 ...)
다음 예에서 Inc-데코레이터 함수를 장식하는 데 사용됩니다. 또한 와
두 개의 매개변수를 취하고 다음과 같은 값으로 데코레이팅된 함수를 호출하는 함수입니다.
1씩 증가합니다. 또한 값 1과 1로 호출되면 끝납니다.
결과는 4(1 + 1 + 1 + 1).
=> (inc-데코레이터 정의 [func]
... (fn [값-1 값-2] (func (+ 값-1 1) (+ 값-2 1))))
=> (inc2-데코레이터 정의 [func]
... (fn [값-1 값-2] (func (+ 값-1 2) (+ 값-2 2))))
=> (장식 포함 inc-장식자 (defn 추가 [ab] (+ ab)))
=> (추가 1 1)
4
=> (with-데코레이터 inc2-데코레이터 inc-데코레이터
... (추가 정의 [ab] (+ ab)))
=> (추가 1 1)
8
with-gensyms
버전 0.9.12의 새로운 기능.
with-gensym 세트를 생성하는 데 사용됩니다. 젠심 매크로에 사용하기 위해. 다음 코드:
(gensyms [abc]
~)
확장 :
([[a (gensym)
[b (젠심)
[c(겐심)]]
~)
만나다 또한:
섹션 using-gensym
수율
수율 하나 이상의 값을 반환하는 생성기 개체를 만드는 데 사용됩니다. 발전기
반복 가능하므로 루프, 목록 이해 및 기타 유사한 방식으로 사용할 수 있습니다.
구성.
기능 난수 생성기를 사용하여 무한 계열을 생성하는 방법을 보여줍니다.
무한한 양의 메모리를 소비하지 않고.
=> ([기본 계수] 곱하기 정의
... ([[(, 기본 계수) (zip 기본 계수)]]
... (수율 (* 기본 계수))))
=> (곱하기 (범위 5) (범위 5))
=> (list-comp 값 [값 (곱하기 (범위 10) (범위 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
=> (임의로 가져오기)
=> (난수 정의 [낮음 높음]
... (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 핵심
핵심 기능
그러나 마지막
용법: (그러나 마지막으로 콜)
마지막 항목을 제외한 모든 항목의 반복자를 반환합니다. 콜.
=> (목록(그러나 마지막 (범위 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]
=> (목록(그러나 마지막 [1]))
[]
=> (목록(그러나 마지막 []))
[]
=> (itertool 가져오기)
=> (목록(5개 취함(butlast (itertools.count 10))))
[10]
콜?
버전 0.10.0의 새로운 기능.
용법: (콜? x)
반품 참된 if x 반복 가능하며 문자열이 아닙니다.
=> (콜? [1 2 3 4])
참된
=> (콜? {"a" 1 "b" 2})
참된
=> (콜? "abc")
거짓
죄수
버전 0.10.0의 새로운 기능.
용법: (단점 a b)
자동차와 함께 새로운 단점 세포를 반환합니다. a 및 CDR b.
=> (setv a (cons 'hd 'tl))
=> (= 'hd (자동차 a))
참된
=> (= 'tl (cdr a))
참된
단점?
버전 0.10.0의 새로운 기능.
용법: (단점? 푸)
여부를 확인합니다. 푸 단점 셀입니다.
=> (setv a (cons 'hd 'tl))
=> (단점?)
참된
=> (단점? 없음)
거짓
=> (단점? [1 2 3])
거짓
12월
용법: (XNUMX월 x)
다음보다 XNUMX 작은 값을 반환합니다. x. 에 해당 (- x 1). 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (3월 XNUMX일)
2
=> (0월 XNUMX일)
-1
=> (12.3월 XNUMX일)
11.3
분해
버전 0.10.0의 새로운 기능.
용법: (분해하다 나무 &선택 과목 [코드젠 거짓])
주어진 Hy에 대해 Python AST를 덤프합니다. 나무 표준 출력으로. 만약에 코드젠 is 참된, 함수
대신 Python 코드를 인쇄합니다.
=> ('('Hello World!' 인쇄) 분해))
기준 치수(
본문=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], 키워드=[], starargs=None, kwargs=None))])
=> ('("Hello World!" 인쇄) 분해) true)
print('안녕하세요!')
비어있는?
용법: (비어 있는? 콜)
반품 참된 if 콜 비었다. 동등하다 (= 0 (렌 콜)).
=> (비어있나요? [])
참된
=> (비어있나요? "")
참된
=> (비어있나요? (, 1 2))
거짓
모든?
버전 0.10.0의 새로운 기능.
용법: (모든? 전에 콜)
반품 참된 if (예상 x) 모든 경우에 논리적으로 참입니다. x in 콜그렇지 않으면 거짓. 반환 참된
if 콜 비었다.
=> (매번? 심지어? [2 4 6])
참된
=> (매번? 심지어? [1 3 5])
거짓
=> (매번? 심지어? [2 4 5])
거짓
=> (매번? 심지어? [])
참된
뜨다?
용법: (뜨다? x)
반품 참된 if x 플로트입니다.
=> (플로트? 3.2)
참된
=> (플로트? -2)
거짓
심지어?
용법: (심지어? x)
반품 참된 if x 짝수이다. 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (심지어? 2)
참된
=> (심지어? 13)
거짓
=> (심지어? 0)
참된
정체
용법: (신원 x)
함수에 제공된 인수를 반환합니다.
=> (신분증 4)
4
=> (목록(맵 ID [1 2 3 4]))
[1 2 3 4]
INC
용법: (포함 x)
다음보다 하나 더 반환합니다. x. 에 해당 (+ x 1). 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (3개 포함)
4
=> (0개 포함)
1
=> (12.3개 포함)
13.3
예?
용법: (사례? 수업 x)
반품 참된 if x 의 인스턴스입니다 수업.
=> (인스턴스? float 1.0)
참된
=> (인스턴스? int 7)
참된
=> (인스턴스? str (str "foo"))
참된
=> (TestClass [객체] 정의 클래스)
=> (setv inst(TestClass))
=> (인스턴스? TestClass inst)
참된
정수?
용법: (정수? x)
반품 참된 if x 정수입니다. Python 2의 경우 이는 다음 중 하나입니다. INT or 긴. 파이썬 3의 경우,
이쪽은 INT.
=> (정수? 3)
참된
=> (정수? -2.4)
거짓
인터리브
버전 0.10.1의 새로운 기능.
용법: (인터리브 시퀀스1 시퀀스2 ~)
각 시퀀스의 첫 번째 항목에 대한 반복 가능 항목을 반환한 다음 두 번째 항목 등을 반환합니다.
=> (목록(인터리브(범위 5) (범위 100 105)))
[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)
반품 참된 if x 반복 가능합니다. 반복 가능한 객체는 다음과 같은 경우 새 반복자를 반환합니다. (반복 x) is
라고 불리는. 대조 반복자?.
=> ;; 문자열에서 작동
=> (반복 가능합니까? (str "abcde"))
참된
=> ;; 목록에서 작동
=> (반복 가능? [1 2 3 4 5])
참된
=> ;; 튜플에서 작동
=> (반복 가능? (, 1 2 3))
참된
=> ;; dicts에서 작동
=> (반복 가능? {:a 1 :b 2 :c 3})
참된
=> ;; 반복자/생성자에서 작동합니다.
=> (반복 가능합니까? (3번 반복))
참된
반복자?
용법: (반복자? x)
반품 참된 if x 반복자입니다. 반복자는 자신을 다음과 같이 반환하는 객체입니다.
반복자 언제 (반복 x) 호출됩니다. 대조 반복 가능?.
=> ;; 목록에서는 작동하지 않습니다
=> (반복자? [1 2 3 4 5])
거짓
=> ;; 하지만 우리는 목록에서 iter를 얻을 수 있습니다
=> (반복자? (iter [1 2 3 4 5]))
참된
=> ;; dict에서는 작동하지 않습니다
=> (반복자? {:a 1 :b 2 :c 3})
거짓
=> ;; dict에서 반복자를 만듭니다.
=> (반복자? (iter {:a 1 :b 2 :c 3}))
참된
목록*
용법: (목록* 머리 &나머지 꼬리)
인수를 포함하는 중첩된 cons 셀(점으로 구분된 목록) 체인을 생성합니다. 만약
인수 목록에는 요소가 하나만 있으므로 반환합니다.
=> (목록* 1 2 3 4)
(1 2 3 . 4)
=> (목록* 1 2 3 [4])
[1, 2, 3, 4]
=> (목록* 1)
1
=> (단점? (목록* 1 2 3 4))
참된
거시적으로 확장하다
버전 0.10.0의 새로운 기능.
용법: (거시 확장 형태)
전체 매크로 확장을 반환합니다. 형태.
=> (매크로 확장 '(-> (ab) (xy)))
(u'x' (u'a' u'b') u'y')
=> (매크로 확장 '(-> (ab) (-> (cd) (ef))))
(u'e' (u'c' (u'a' u'b') u'd') u'f')
매크로확장-1
버전 0.10.0의 새로운 기능.
용법: (매크로확장-1 형태)
단일 단계 매크로 확장을 반환합니다. 형태.
=> (macroexpand-1 '(-> (ab) (-> (cd) (ef))))
(u'_>' (u'a' u'b') (u'c' u'd') (u'e' u'f'))
와 합치다
버전 0.10.1의 새로운 기능.
용법: (와 합치다 f &나머지 지도)
먼저 결합된 나머지 지도로 구성된 지도를 반환합니다. 키가 발생하는 경우
두 개 이상의 맵이 있는 경우 후자의 매핑(왼쪽에서 오른쪽으로)이 다음과 결합됩니다.
호출을 통한 결과 매핑 (f 결과값 발인-후자).
=> (병합 (fn [xy] (+ xy)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a': 11L, u'c': 30L, u'b': 20L}
응?
용법: (아니? x)
반품 참된 if x XNUMX보다 작습니다. 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (부정? -2)
참된
=> (부정? 3)
거짓
=> (부정? 0)
거짓
무?
용법: (무? x)
반품 참된 if x is 무 / 없음.
=> (전혀? 전무)
참된
=> (없음? 없음)
참된
=> (0? XNUMX)
거짓
=> (setf x nil)
=> (없음? x)
참된
=> ;; list.append는 항상 None을 반환합니다.
=> (없음? (.append [1 2 3] 4))
참된
없음?
용법: (없음? x)
반품 참된 if x is 없음.
=> (없음? 없음)
참된
=> (없음? 0)
거짓
=> (setf x 없음)
=> (없음? x)
참된
=> ;; list.append는 항상 None을 반환합니다.
=> (없음? (.append [1 2 3] 4))
참된
n 번째
용법: (n번째 콜 n &선택 과목 [기본 무])
반환 n- 0부터 계산되는 컬렉션의 번째 항목입니다. 기본값을 반환합니다. 무만약
범위를 벗어났습니다(달리 지정하지 않는 한). 레이즈 값 오류 if n 부정적이다.
=> (n번째 [1 2 4 7] 1)
2
=> (n번째 [1 2 4 7] 3)
7
=> (없음? (n번째 [1 2 4 7] 5))
참된
=> (n번째 [1 2 4 7] 5 "기본값")
'기본'
=> (n번째 (3개를 취함 (드롭 2 [1 2 3 4 5 6])) 2))
5
=> (n번째 [1 2 4 7] -1)
추적 (최근 호출 마지막) :
...
ValueError: islice()의 인덱스는 None 또는 정수여야 합니다: 0 <= x <= sys.maxsize.
숫자?
용법: (숫자? x)
반품 참된 if x Python의 정의에 따라 숫자입니다. 숫자.번호 클래스입니다.
=> (숫자? -2)
참된
=> (숫자? 3.2)
참된
=> (숫자? "foo")
거짓
이상한?
용법: (이상한? x)
반품 참된 if x 이상하다. 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (이상하다? 13)
참된
=> (이상하다? 2)
거짓
=> (이상하다? 0)
거짓
포스?
용법: (그럴까요? x)
반품 참된 if x XNUMX보다 큽니다. 레이즈 유형 오류 if (아니신가요 (숫자? 엑스)).
=> (위치? 3)
참된
=> (pos? -2)
거짓
=> (위치? 0)
거짓
초
용법: (두번째 콜)
의 두 번째 멤버를 반환합니다. 콜. 에 해당 (가져 오기 콜 1).
=> (초 [0 1 2])
1
일부
버전 0.10.0의 새로운 기능.
용법: (약간 전에 콜)
논리적으로 참인 첫 번째 값을 반환합니다. (예상 x) 어떤을 위해 x in 콜그렇지 않으면 무.
반품 무 if 콜 비었다.
=> (일부? [2 4 6])
참된
=> (전혀 없나요? (일부 짝수? [1 3 5]))
참된
=> (없음? (일부 신원 [0 "" []]))
참된
=> (일부 ID [0 "비어 있지 않은 문자열" []])
'비어 있지 않은 문자열'
=> (전혀 없나요? (몇몇은 심지어? []))
참된
끈?
용법: (끈? x)
반품 참된 if x 문자열입니다.
=> (문자열? "foo")
참된
=> (문자열? -2)
거짓
상징?
용법: (상징? x)
반품 참된 if x 상징이다.
=> (기호? 'foo)
참된
=> (기호? '[abc])
거짓
제로?
용법: (영? x)
반품 참된 if x XNUMX입니다.
=> (3? XNUMX)
거짓
=> (2? -XNUMX)
거짓
=> (0? XNUMX)
참된
순서 기능
시퀀스 함수는 잠재적으로 무한한 시퀀스를 생성하거나 작동할 수 있습니다.
목록이나 유사한 컨테이너에서 시퀀스를 완전히 실현해야 합니다. 그들은 이것을 통해
Python 반복자를 반환합니다.
사용 방법의 예로 표준 무한 피보나치 수 생성기를 사용할 수 있습니다.
이러한 기능 중 일부.
(fib 정의 []
(0으로 설정)
(세트비 1)
(사실이지만
(a를 산출하다)
(setv (, ab) (, b (+ ab)))))
참고 사항 (동안 참된 ~) 고리. REPL에서 이것을 실행하면,
=> (fib)
함수를 호출하면 반복자만 반환되지만 이를 사용할 때까지는 아무 작업도 수행되지 않습니다.
이와 같은 시도는 무한 루프가 실행될 때까지 실행되므로 권장되지 않습니다.
사용 가능한 모든 RAM을 소모합니다. 이 경우에는 RAM을 죽일 때까지 소모합니다.
=> (목록(fib))
[1] 91474명이 hy를 죽였습니다.
처음 10개의 피보나치 수를 얻으려면 다음을 사용하십시오. 받아. 그 주 받아 또한 생성기를 반환합니다.
그래서 나는 그것으로부터 목록을 만듭니다.
=> (목록(10개(fib)))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
인덱스 9에서 피보나치 수를 얻으려면(0부터 시작):
=> (n번째(fib) 9)
34
주기
용법: (주기 콜)
coll 멤버의 무한 반복자를 반환합니다.
=> (목록(7개(사이클 [1 2 3]))))
[1, 2, 3, 1, 2, 3, 1]
=> (목록(2개(사이클 [1 2 3]))))
[1, 2]
뚜렷한
용법: (별개의 콜)
의 고유한 멤버만 포함하는 반복자를 반환합니다. 콜.
=> (목록(고유한 [ 1 2 3 4 3 5 2 ]))
[1]
=> (목록(고유한 []))
[]
=> (목록(고유한 (iter [ 1 2 3 4 3 5 2 ])))
[1]
드롭
용법: (떨어지다 n 콜)
첫 번째를 건너뛰고 반복자를 반환합니다. n 회원 콜. 레이즈 값 오류 if n is
부정.
=> (목록(드롭 2 [1 2 3 4 5]))
[3, 4, 5]
=> (목록(드롭 4 [1 2 3 4 5]))
[5]
=> (목록(드롭 0 [1 2 3 4 5]))
[1]
=> (목록(드롭 6 [1 2 3 4 5]))
[]
드롭 마지막
용법: (드롭 마지막 n 콜)
마지막을 제외한 모든 반복자를 반환합니다. n 항목 콜. 레이즈 값 오류 if n is
부정.
=> (목록(마지막 5개(범위 10 20)))
[10]
=> (목록(마지막 드롭 0(범위 5)))
[0]
=> (목록(마지막 드롭 100(범위 100)))
[]
=> (itertool 가져오기)
=> (목록(5개(마지막 100개(itertools.count 10)))))
[10]
잠시 쉬는 동안
용법: (드롭하는 동안 전에 콜)
멤버를 건너뛰고 반복자를 반환합니다. 콜 까지 전에 is 거짓.
=> (목록(드롭하는 동안에도? [2 4 7 8 9]))
[7, 8, 9]
=> (목록(드롭 동안 숫자? [1 2 3 없음 "a"])))
[아냐, 아아']
=> (목록(드롭 위치? [2 4 7 8 9]))
[]
필터링
용법: (필터 전에 콜)
의 모든 항목에 대한 반복자를 반환합니다. 콜 술어를 통과하는 것 전에.
참조 제거.
=> (목록(필터 위치? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]
=> (목록(짝수 필터링? [1 2 3 -4 5 -7]))
[2, -4]
반음 낮추다
버전 0.9.12의 새로운 기능.
용법: (단조롭게 하다 콜)
에 있는 모든 항목의 단일 목록을 반환합니다. 콜, 포함된 모든 목록 및/또는
튜플.
=> (평평화 [1 2 [3 4] 5])
[1]
=> (평탄화 ["foo" (, 1 2) [1 [2 3] 4] "bar"])
['foo', 1, 2, 1, 2, 3, 4, '바']
반복하다
용법: (반복하다 fn x)
의 반복자를 반환합니다. x, fn(엑스), fn(fn(엑스))등
=> (목록(5개를 취함(5개를 포함하여 반복)))
[5]
=> (목록(5개를 취함(반복(fn [x] (* xx)) 5)))
[5]
읽기
용법: (독서 &선택 과목 [파일에서 에프])
다음 Hy 표현식을 읽습니다. 파일에서 (기본값 sys.stdin),
단일 바이트를 EOF로 사용합니다(기본값은 빈 문자열). 레이즈 EOF오류 if 파일에서 전에 종료
완전한 표현식을 구문 분석할 수 있습니다.
=> (읽기)
(+ 2 2)
('+' 2 2)
=> (평가(읽기))
(+ 2 2)
4
=> (IO 가져오기)
=> (def 버퍼 (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (읽기 [] {"from_file" 버퍼} 적용))
4
=> (eval (읽기 [] {"from_file" 버퍼} 적용))
1
=> ; "example.hy"에 다음이 포함되어 있다고 가정합니다.
=> ; ("안녕하세요" 인쇄)
=> ; ("하이프렌드!" 인쇄)
=> ([[f ("example.hy" 열기)]] 사용
... (노력하다
... (사실이지만
... ([[exp (f를 읽음)]]
... (하다
... ("OHY" exp 인쇄)
... (평가 경험))))
... ([e EOFError]를 잡아라
... ("EOF!" 인쇄))))
OHY('인쇄' '안녕하세요')
안녕하세요
OHY ('인쇄' '하이프렌즈!')
하이프렌즈!
엑!
제거
용법: (제거하다 전에 콜)
다음에서 반복자를 반환합니다. 콜 술어를 전달하는 요소로, 전에, 제거됨.
참조 필터링.
=> (목록(홀수를 제거하시겠습니까? [1 2 3 4 5 6 7]))
[2, 4, 6]
=> (목록(위치를 제거하시겠습니까? [1 2 3 4 5 6 7]))
[]
=> (목록(부정을 제거하시겠습니까? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]
반복
용법: (반복하다 x)
다음의 반복자(무한)를 반환합니다. x.
=> (목록(6개("s" 반복)))
[유', 유', 유', 유', 유', 유']
자꾸
용법: (자꾸 fn)
호출하여 반복자를 반환합니다. fn 자꾸.
=> (가져오기 [임의 [randint]])
=> (목록(5개 취함(반복적으로 (fn [] (randint 0 10)))))
[6]
받아
용법: (갖다 n 콜)
첫 번째를 포함하는 반복자를 반환합니다. n 회원 콜. 레이즈 값 오류 if n is
부정.
=> (목록(3 [1 2 3 4 5]))
[1, 2, 3]
=> (목록(4개("s" 반복)))
[너, 너, 너, 너]]
=> (목록(0개("s" 반복)))
[]
테이크 앤
용법: (테이크-n번째 n 콜)
다음을 포함하는 반복자를 반환합니다. n-번째 멤버 콜.
=> (목록(n번째 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]
=> (목록(n번째 3 [1 2 3 4 5 6 7]))
[1, 4, 7]
=> (목록(n번째 4 [1 2 3 4 5 6 7]))
[1, 5]
=> (목록(n번째 10 [1 2 3 4 5 6 7]))
[1]
소요 시간
용법: (소요시간 전에 콜)
다음에서 반복자를 반환합니다. 콜 만큼 전에 반품 참된.
=> (목록(촬영하는 동안 위치? [ 1 2 3 -4 5]))
[1, 2, 3]
=> (목록(수행하는 동안 부정? [ -4 -3 1 2 5]))
[-4, -3]
=> (목록(취소하는 동안 부정? [ 1 2 3 -4 5]))
[]
zip으로
버전 0.9.13의 새로운 기능.
용법: (zip으로 fn 콜 ~)
에 해당 지퍼, 그러나 튜플을 생성하는 대신 다중 인수 함수를 사용합니다. 만약에
zip으로 N개의 컬렉션으로 호출된 다음 fn N개의 인수를 허용해야 합니다.
=> (가져오기 연산자)
=> (목록(zipwith Operator.add [1 2 3] [4 5 6]))
[5, 7, 9]
리더 매크로
리더 매크로는 Lisp에게 구문을 즉시 수정하고 변경할 수 있는 기능을 제공합니다. 당신은 원하지 않는다
폴란드 표기법? 리더 매크로는 쉽게 그렇게 할 수 있습니다. Clojure의 방식을 원함
정규식? 리더 매크로도 이 작업을 쉽게 수행할 수 있습니다.
통사론
=> (defreader ^ [expr] (인쇄 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] (인쇄 expr))
;=> (with_ decorator (hy.macros.reader ^) (fn [expr] (인쇄 expr)))
# 로 확장 (dispatch_reader_macro ~) 기호와 표현이 전달되는 곳
올바른 기능.
=> #^()
;=> (dispatch_reader_macro ^())
=> #^"안녕하세요"
"여보세요"
경고 :
Hy의 어휘 분석기 및 파서의 제한으로 인해 리더 매크로는 정의된 내용을 재정의할 수 없습니다.
다음과 같은 구문 ()[]{}. 이 문제는 앞으로 해결될 가능성이 높습니다.
내부의 Hy 문서
알림:
이 비트는 Hy 자체를 해킹하는 사람들에게 주로 유용하지만 다음 용도로도 사용할 수 있습니다.
매크로 프로그래밍에 대해 더 깊이 탐구하는 사람들.
Hy 모델
개요 에 Hy 모델
Hy 모델은 Hy 소스를 나타내는 일반 Python 객체 위에 있는 매우 얇은 레이어입니다.
데이터로서의 코드. 모델은 소스 위치 정보와 몇 가지 방법만 추가합니다.
예를 들어 매크로에서 Hy 소스 코드의 깔끔한 조작을 지원합니다. 그것을 달성하려면
목표, Hy 모델은 기본 Python 클래스와 HyObject.
HyObject
hy.models.HyObject Hy 모델의 기본 클래스입니다. 한 가지 메소드만 구현합니다. 교체,
이는 현재 객체의 소스 위치를 인수로 전달된 위치로 바꿉니다.
이를 통해 수정된 표현식의 원래 위치를 추적할 수 있습니다.
매크로는 컴파일러에 있거나 순수한 hy 매크로에 있습니다.
HyObject Hy 모델을 인스턴스화하는 데 직접 사용되지 않고 믹스인으로만 사용됩니다.
다른 수업의 경우.
화합물 모델
괄호로 묶인 목록과 괄호로 묶인 목록은 Hy 파서에 의해 복합 모델로 구문 분석됩니다.
하이리스트
hy.models.list.HyList "반복 가능한" Hy 모델의 기본 클래스입니다. 기본적인 용도는 다음과 같습니다.
괄호 안에 표시 [] 최상위 표현식으로 사용될 때 다음으로 변환되는 목록
컴파일 단계의 Python 목록 리터럴.
다른 반복 가능한 객체에 HyList를 추가하면 왼쪽 객체의 클래스가 재사용됩니다.
예를 들어 매크로에서 Hy 개체를 연결하려는 경우 유용한 동작입니다.
Hy표현
hy.models.expression.HyExpression 상속 하이리스트 괄호 안의 () 표현. 그만큼
해당 표현식의 컴파일 결과는 목록의 첫 번째 요소에 따라 달라집니다.
컴파일러는 컴파일러 특수 형식, 사용자 정의 매크로 및 사이에 표현식을 전달합니다.
일반 Python 함수 호출.
하이딕트
hy.models.dict.HyDict 상속 하이리스트 중괄호의 경우 {} 컴파일되는 표현식
Python 사전 리터럴까지.
dict 대신 목록을 기본 클래스로 사용하기로 결정 하이딕트 더 쉽게 허용
복합 표현을 허용하는 추가 이점과 함께 매크로에서 사전 조작
dict 키로(예를 들어 Hy표현 Python 클래스는 해시 가능하지 않습니다.)
원자의 모델
입력 스트림에서 문자열에 대한 Python 표기법을 고려하여 큰따옴표로 묶인 문자열은
단일 토큰으로 구문 분석되며, 이는 다음과 같이 직접 구문 분석됩니다. 하이스트링.
공백, 대괄호, 따옴표, 큰따옴표를 제외한 연속된 문자열
및 주석은 식별자로 구문 분석됩니다.
식별자는 구문 분석 단계에서 다음 순서로 원자 모델로 확인됩니다.
· HyInteger
· 하이플로트
· 하이컴플렉스 (원자가 맨손이 아닌 경우 j)
· 하이키워드 (원자가 다음으로 시작하는 경우 :)
· 하이심볼
하이스트링
hy.models.string.HyString 문자열에 해당하는 Hy 모델의 기본 클래스입니다. 또한
큰따옴표로 묶인 문자열 리터럴을 나타냅니다. "", 유니코드 문자열로 컴파일됩니다.
Python의 리터럴. HyStrings Python 2에서는 유니코드 객체를 상속하고 Python XNUMX에서는 문자열 객체를 상속합니다.
Python 3(따라서 인코딩에 종속되지 않음)
하이스트링 기반 모델은 변경할 수 없습니다.
Hy 리터럴 문자열은 여러 줄에 걸쳐 있을 수 있으며 파서에서 단일 문자열로 간주됩니다.
유니코드 문자열에 대한 Python 이스케이프를 존중하는 단위입니다.
숫자 모델
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 상호 운용성을 돕기 위해 구문 분석 단계에서 객체가 손상됩니다.
· 별표로 둘러싸인 기호(*)은 대문자로 변경됩니다.
· 대시(-)는 밑줄(_);
· 하나의 후행 물음표(?)는 선두로 바뀌었다 이다_.
주의 사항: 분석 단계에서 맹글링이 수행되므로 다음이 가능합니다.
Hy 소스 코드로 생성할 수 없는 HySymbol을 프로그래밍 방식으로 생성합니다. 이러한
메커니즘은 gensym이 "인터닝되지 않은" 기호를 생성하는 데 사용됩니다.
하이키워드
hy.models.keyword.Hy키워드 Hy의 키워드를 나타냅니다. 키워드는 다음으로 시작하는 기호입니다.
a :. 클래스는 상속 하이스트링.
구별하기 위해 하이키워드 에 Hy심볼, (비자발적) 가능성 없이
충돌, 개인용 유니코드 문자 "\uFDD0" 키워드 리터럴 앞에 추가됩니다.
보관 전.
단점 셀
hy.models.cons.HyCons Python 친화적인 표현입니다. 죄수 세포. 단점 세포는
Scheme 또는 Common과 같은 "일반적인" LISP 변형의 기능을 모방하는 데 특히 유용합니다.
Lisp.
단점 셀은 다음을 포함하는 2개 항목 개체입니다. 자동차 (머리) 그리고 cdr (꼬리). 일부 Lisp에서는
변형에서 단점 셀은 기본 구성 요소이고 S-표현식은 실제로
단점 셀의 연결된 목록으로 표시됩니다. 평소와 같이 Hy에서는 그렇지 않습니다.
표현식은 다음과 같이 포장된 Python 목록으로 구성됩니다. Hy표현. 그러나, 그 하이콘
다음과 같이 "일반적인" Lisp 변형의 동작을 모방합니다.
· (단점 무언가 무) is (Hy표현 [무엇])
· (단점 무언가 일부 목록) is ((유형 일부 목록) (+ [무엇] 일부 목록)) (만약
일부 목록 ~로부터 상속 받다 명부).
· (가져 오기 (단점 a b) 0) is a
· (일부분 (단점 a b) 1) is b
Hy는 점으로 구분된 목록 구문을 지원합니다. '(ㅏ . b) 방법 (단점 'a '비) 과 '(ㅏ b . c) 방법
(단점 'a (단점 'b '씨)). 컴파일러가 최상위 수준에서 단점 셀을 발견하면 다음이 발생합니다.
컴파일 오류.
하이콘 전달된 인수(car 및 cdr)를 Hy 유형으로 래핑하여 조작을 용이하게 합니다.
거시적 맥락에서 단점 셀.
Hy 내부의 이론
살펴보기
Hy 내부는 Python 바이트코드의 프런트엔드 역할을 하여 작동합니다.
Python 바이트코드로 컴파일하여 수정되지 않은 Python 런타임에서 Hy 코드를 실행할 수 있도록 합니다.
눈치채지도 못한 채.
이를 수행하는 방법은 Hy를 내부 Python AST 데이터 구조로 변환하는 것입니다.
Python 표준의 모듈을 사용하여 해당 AST를 Python 바이트코드로 구축
라이브러리를 사용하여 모든 Python 내부 작업을 복제할 필요가 없도록 합니다.
단일 Python 릴리스.
Hy는 XNUMX단계로 작동합니다. 다음 섹션에서는 소스에서 Hy의 각 단계를 다룹니다.
실행 시간.
단계 1 과 2: 토큰 화하기 과 파싱
Hy 컴파일의 첫 번째 단계는 소스를 우리가 처리할 수 있는 토큰으로 렉싱하는 것입니다. 우리
하위 집합으로 작성된 정말 훌륭하고 빠른 파서인 rply라는 프로젝트를 사용하세요.
Python의 rpython이라고 합니다.
렉싱 코드는 모두 다음에 정의되어 있습니다. hy.lex.렉서. 이 코드는 대부분 Hy를 정의하는 것입니다.
문법, 실제 어려운 부분은 모두 rply에 의해 처리됩니다. 우리는 단지 정의만 하면 됩니다.
rply in에 대한 "콜백" hy.lex.파서, 생성된 토큰을 가져와서 반환합니다.
하이 모델들.
Hy 모델을 Hy의 "AST"로 생각할 수 있습니다. 이는 매크로가 작동하는 방식입니다.
(직접) 그리고 이는 컴파일러가 Hy를 컴파일할 때 사용하는 것입니다.
만나다 또한:
섹션 Hy 모델 Hy 모델과 그 의미에 대한 자세한 내용은 여기를 참조하세요.
단계 3: Hy 편집 에 Python AST
Hy의 마법이 대부분 일어나는 곳은 바로 여기입니다. 이곳은 Hy AST(모델)를 데리고 가는 곳입니다.
Python AST로 컴파일합니다. 몇 가지 지난 일을 하기 위해 여기에서 몇 가지 펑키한 일이 일어납니다.
AST의 문제를 해결하고 컴파일러에서 작업하는 것은 우리가 하는 가장 중요한 작업 중 일부입니다.
있다.
컴파일러는 약간 복잡하므로 첫 번째 샷에서 이해하지 못하더라도 기분 나빠하지 마십시오.
제대로 처리하는 데 약간의 시간이 걸릴 수 있습니다.
컴파일러의 주요 진입점은 다음과 같습니다. HyASTCompiler.compile. 이 메소드가 호출되고,
클래스의 유일한 실제 "공개" 메서드(즉, 우리는 실제로
해당 메소드 이상의 API).
실제로 내부적으로도 직접적으로 재귀하는 경우는 거의 없으며 거의 항상 강제로
하이트리를 통해 편집하다, 표현식의 하위 요소를 사용하여 이 작업을 수행하는 경우가 많습니다.
우리가 가지고 있는 것. 하위 요소를 올바르게 디스패치하는 것은 유형 기반 디스패처에 달려 있습니다.
컴파일을 수행하는 모든 메소드는 @빌드() 데코레이터. 당신은 할 수 있습니다
컴파일하는 Hy 모델의 클래스를 전달하거나 문자열을 사용할 수 있습니다.
표현. 잠시 후에 이 문제를 정리하겠습니다.
먼저, 단계 유형 파견
에서 시작하자 편집하다 방법. 가장 먼저 할 일은 사물의 유형을 확인하는 것입니다.
우리는 건물을 짓고 있어요. 우리는 유형() 우리는
갖고 이를 처리할 수 있는 메서드로 전달합니다. 우리가 할 수 있는 메소드가 없다면
해당 유형을 구축하면 내부 예외.
예를 들어, 하이스트링, Hy AST와 Python의 거의 1:1 매핑이 있습니다.
AST. 그만큼 컴파일_문자열 방법은 하이스트링, 그리고 반환 ast.Str() 그건
올바른 줄 번호와 내용으로 채워집니다.
매크로 확장
우리가 얻는다면 Hy표현, 우리는 이것이 알려진 매크로인지 확인하고
호출하여 확장되었습니다. hy.macros.macroexpand, 그런 다음 결과를 다시 푸시합니다.
HyASTCompiler.compile.
둘째 단계 표현식-디스패치
유일한 특별한 경우는 Hy표현, 따라 다른 AST를 생성해야 하기 때문입니다.
문제의 특별 양식에 대해. 예를 들어, 우리가 (만약 참된 참된 거짓)우리
생성해야합니다 ast.If, 하위 노드를 올바르게 컴파일합니다. 이곳은 @빌드()
문자열을 인수로 사용하여 들어옵니다.
다음 컴파일 표현식 (이는 @builds(하이익스프레션)) 파견하겠습니다
첫 번째 인수의 문자열을 기반으로 합니다. 어떤 이유로든 첫 번째 인수가 그렇지 않은 경우
문자열을 사용하면 해당 경우도 적절하게 처리합니다(대부분 예외).
문자열이 Hy에 알려지지 않은 경우 기본적으로 문자열을 생성합니다. ast.전화, 이는 다음을 시도할 것입니다.
런타임 호출을 수행합니다(Python에서는 다음과 같습니다. foo ()).
문제 히트 과 Python AST
Python AST는 훌륭합니다. 이것이 바로 우리가 그토록 강력한 프로젝트를 작성할 수 있게 해 준 것입니다.
Python과 너무 심하게 싸울 필요 없이 Python을 사용할 수 있습니다. 다른 것과 마찬가지로 우리는 공평한 몫을 가지고 있습니다.
다음은 발생할 수 있는 일반적인 문제의 간단한 목록입니다.
Python 차별화 사이에 명세서 과 식.
이것은 큰 문제처럼 들리지 않을 수도 있습니다. 사실 대부분의 Python 프로그래머에게는 이것이
곧 "글쎄, 그래" 순간이 됩니다.
Python에서는 다음과 같은 작업을 수행합니다.
인쇄 for x in 범위(10) : 패스, 때문에 인쇄 표현식을 인쇄하고 for 는 아니다
표현식은 제어 흐름 문입니다. 같은 것들 1 + 1 표현식은 그대로입니다. 람다
x: 1 + x, 그러나 다음과 같은 다른 언어 기능 if, for 및 동안 진술이다.
Python에는 "가치"가 없기 때문에 Hy에서 작업하는 것이 어려워집니다.
처럼 (인쇄 (만약 참된 참된 거짓)) 일반적인 일이 아니라 예상되는 일입니다.
결과적으로 우리는 결과 우리가 무엇이든 제공하는 곳 ast.stmt
실행해야 하는 항목과 단일 ast.expr 무엇이든 가치를 얻는 데 사용할 수 있습니다.
방금 실행되었습니다. Hy는 달리는 동안 사물에 강제로 할당함으로써 이를 수행합니다.
예를 들어, Hy:
(인쇄(참인 경우 참 거짓))
다음과 같이 변합니다:
만약 사실이라면:
_mangled_name_here = 참
그밖에:
_mangled_name_here = 거짓
_mangled_name_here를 인쇄하세요.
좋아요, 그것은 약간의 거짓말이었습니다. 실제로 그 진술을 다음과 같이 바꾸었기 때문입니다.
True이면 True를 인쇄하고 그렇지 않으면 False를 인쇄합니다.
일을 강제로 함으로써 ast.expr 가능하다면 일반적인 생각은 유효합니다.
단계 4: Python 바이트 코드 산출 과 런타임
Python AST 트리가 완성되면 Python으로 컴파일해 볼 수 있습니다.
푸시하여 바이트 코드 평가. 이제부터 우리는 더 이상 통제할 수 없습니다.
Python이 모든 것을 처리합니다. 이것이 Python 추적, pdb 및
django 앱이 작동합니다.
Hy 매크로
사용 젠심 for 더 안전한 매크로
매크로를 작성할 때 외부 변수를 캡처하거나 매크로를 사용하지 않도록 주의해야 합니다.
사용자 코드와 충돌할 수 있는 변수 이름.
예제 매크로를 사용하겠습니다. nif (참조
http://letoverlambda.com/index.cl/guest/chap3.html#초_5 더 자세한 설명을 원하시면.)
nif 예입니다. 숫자와 같은 것입니다. if, 여기서 표현식을 기반으로 하면 다음 중 하나가 됩니다.
식이 양수, 3, 음수인지에 따라 XNUMX가지 형식이 호출됩니다.
첫 번째 패스는 다음과 같을 수 있습니다.
(defmacro nif [expr pos-form zero-form neg-form]
`(let [[모호한 이름 ~expr]]
(cond [(pos? 모호한 이름) ~pos-form]
[(zero? 모호한 이름) ~zero-form]
[(부정? 모호한 이름) ~부정 형식])))
어디에 모호한 이름 다른 변수와 충돌하지 않도록 일부 변수 이름을 선택하려는 시도입니다.
암호. 그러나 물론 좋은 의도로 이루어졌다고 해서 이것이 보장되는 것은 아닙니다.
gensym 방법은 그러한 상황에 맞는 새롭고 독특한 상징을 생성하도록 설계되었습니다.
훨씬 더 나은 버전 nif 다음과 같습니다.
(defmacro nif [expr pos-form zero-form neg-form]
([[g (gensym)]] 시키십시오.
`(let [[~g ~expr]]
(cond [(pos? ~g) ~pos-형식]
[(제로? ~g) ~제로 형식]
[(부정? ~g) ~부정 형식]))))
기호가 하나뿐이므로 이는 쉬운 경우입니다. 하지만 여러개 필요하다면
gensym에는 기본적으로 일련의로 확장되는 gensyms가 있는 두 번째 매크로가 있습니다. 하자
진술 :
(gensyms [abc]
~)
확장 :
([[a (gensym)
[b (젠심)
[c(겐심)]]
~)
그래서 우리가 다시 쓴 nif 다음과 같이 보일 것입니다.
(defmacro nif [expr pos-form zero-form neg-form]
(gensyms [g] 포함
`(let [[~g ~expr]]
(cond [(pos? ~g) ~pos-형식]
[(제로? ~g) ~제로 형식]
[(부정? ~g) ~부정 형식]))))
마지막으로 이 모든 작업을 수행하는 새로운 매크로를 만들 수 있습니다. defmacro/g! 취할 것
로 시작하는 모든 기호 g! 자동으로 전화를 걸고 젠심 나머지와 함께
상징. 그래서 가!아 될 것이다 (겐심 "ㅏ").
우리의 최종 버전 nif, 내장 defmacro/g! 다음과 같이됩니다.
(defmacro/g! nif [expr pos-form zero-form neg-form]
`(let [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-형식]
[(zero? ~g!res) ~zero-form]
[(부정? ~g!res) ~부정 형식]))))
확인 매크로 인수 과 인상 예외
Hy 컴파일러 내장
기부자 모듈 INDEX
내용 :
아나포릭 매크로
버전 0.9.12의 새로운 기능.
아나포릭 매크로 모듈은 Hy의 기능적 프로그래밍을 매우 간결하고 쉽게 만듭니다.
읽어보십시오.
아나포릭 매크로는 의도적으로 어떤 형태를 캡처하는 프로그래밍 매크로 유형입니다.
아나포(참조하는 표현)에 의해 참조될 수 있는 매크로에 제공됩니다.
다른 사람에게). — 위키피디아(http://en.wikipedia.org/wiki/Anaphoric_macro)
매크로
만약에
용법: (ap-if (후) (인쇄 그것))
첫 번째 양식의 진실성을 평가하고 이를 바인딩합니다. it 진실과 거짓 모두에서
분기합니다.
복숭아
용법: (복숭아 [1 2 3 4 5] (인쇄 그것))
부작용이 있는지 목록의 각 요소에 대한 양식을 평가합니다.
가끔씩
용법: (ap-each-while 명부 전에 몸)
조건자 형식이 반환되는 각 요소의 형식을 평가합니다. 참된.
=> (ap-each-while [1 2 3 4 5 6] (< it 4) (인쇄))
1
2
3
AP-맵
용법: (ap-지도 형태 목록)
anaphoric 형태의 map은 함수 대신에 일반 map과 동일하게 작동합니다.
물체는 Hy 형태를 취합니다. 특별한 이름 it 현재 개체에 바인딩되어 있습니다.
반복에 나열합니다.
=> (목록(ap-map (* it 2) [1 2 3]))
[2, 4, 6]
AP-맵-언제
용법: (ap-맵-언제 predfn 대표 목록)
조건자 함수를 사용하여 목록에 대한 매핑을 평가하여 언제 적용할지 결정합니다.
양식.
=> (목록(ap-map-홀수일 때? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]
=> (목록(ap-map-짝수일 때? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]
AP 필터
용법: (ap-필터 형태 목록)
와 같은 AP-맵 우리는 요소를 필터링하는 함수 대신 특별한 형식을 사용합니다.
목록. 특별한 이름 it 반복의 현재 요소에 바인딩됩니다.
=> (목록(ap-filter (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]
적절한 거부
용법: (ap-거절 형태 목록)
이 기능은 다음과 반대되는 기능을 수행합니다. AP 필터, 이는 다음을 전달하는 요소를 거부합니다.
술어 . 특별한 이름 it 반복의 현재 요소에 바인딩됩니다.
=> (목록(ap-reject (> (* it 2) 6) [1 2 3 4 5]))
[1, 2, 3]
적절한 시간
용법 (ap-dotimes n 몸)
이 함수는 본문을 평가합니다. n 시간, 특수 변수 it 에서 바인딩 0 에
1-N. 부작용에 유용합니다.
=> (setv n [])
=> (ap-dotimes 3 (.append n it))
=> 엔
[0, 1, 2]
AP 우선
용법 (ap 우선 predfn 목록)
이 함수는 조건자를 전달하는 첫 번째 요소를 반환합니다. 없음,와
특수 변수 it 반복에서 현재 요소에 바인딩됩니다.
=>(ap-first (> it 5) (범위 10))
6
마지막
용법 (ap-마지막 predfn 목록)
이 함수는 조건자를 전달하는 마지막 요소를 반환합니다. 없음, 특별한
변수 it 반복에서 현재 요소에 바인딩됩니다.
=>(ap-last (> it 5) (범위 10))
9
축소하다
용법 (ap-감소 형태 명부 &선택 과목 초기 값)
이 함수는 본문의 처음 2개 요소에 양식을 적용한 결과를 반환하고
목록이 소진될 때까지 결과와 세 번째 요소 등을 적용합니다. 선택적으로
초기값을 제공할 수 있으므로 함수는 초기값에 적용되며
대신 첫 번째 요소. 이는 반복되는 요소를 다음과 같이 노출합니다. it 및 전류
누적된 가치 ACC.
=>(ap-reduce (+ it acc) (범위 10))
45
루프/반복
버전 0.10.0의 새로운 기능.
XNUMXD덴탈의 고리 / 되풀이하다 매크로는 프로그래머에게 TCO(Tail Call Optimization)를 사용하는 간단한 방법을 제공합니다.
Hy 코드에서.
테일 호출은 다른 프로시저 내에서 최종적으로 발생하는 서브루틴 호출입니다.
행동; 반환 값을 생성한 다음 호출에 의해 즉시 반환될 수 있습니다.
절차. 서브루틴이 수행하는 호출이 결국에는
호출 체인 아래에서 다시 호출되는 동일한 서브루틴이 꼬리 위치에 있습니다.
이러한 서브루틴을 꼬리 재귀라고 하며, 이는 재귀의 특별한 경우입니다.
테일 호출은 새 스택을 추가하지 않고도 구현할 수 있으므로 중요합니다.
프레임을 호출 스택에 추가합니다. 현재 절차의 프레임 대부분은 필요하지 않습니다.
더, 테일콜 프레임으로 대체 가능합니다. 그러면 프로그램이 점프할 수 있습니다.
호출된 서브루틴에 표준 호출 시퀀스 대신 이러한 코드를 생성하는 것은
꼬리 호출 제거 또는 꼬리 호출 최적화라고 합니다. 테일 콜 제거가 가능합니다.
goto 문만큼 효율적으로 구현될 꼬리 위치의 프로시저 호출,
따라서 효율적인 구조적 프로그래밍이 가능합니다. — 위키피디아(‐
http://en.wikipedia.org/wiki/Tail_call)
매크로
고리
고리 재귀 지점을 설정합니다. 와 함께 고리, 되풀이하다 에 설정된 변수를 다시 바인딩합니다.
재귀 지점을 찾아 코드 실행을 다시 해당 재귀 지점으로 보냅니다. 만약에 되풀이하다 에서 사용되는
꼬리 위치가 아닌 경우 예외가 발생합니다.
용법: (고리 바인딩 &나머지 몸)
예:
(hy.contrib.loop 필요)
(계승 [n] 정의
(루프 [[in] [acc 1]]
(if (제로? i)
ACC
(반복 (dec i) (* acc i)))))
(계승 1000)
defmulti
버전 0.10.0의 새로운 기능.
defmulti 주어진 인수 및/또는 kwargs 수만큼 함수를 arity-overload할 수 있습니다.
Clojure의 관점에서 영감을 받음 데프.
=> (hy.contrib.multi 필요)
=> (다양한 재미
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (재미 1)
"ㅏ"
=> (재미 1 2)
"ab"
=> (재밌음 1 2 3)
"알파벳"
해킹 ON HY
가입하기 우리의 하이브!
Hy를 해킹해 주세요!
에 우리와 함께 놀러오세요 #hy on irc.freenode.net!
이에 대해 트위터로 이야기해 주세요. #hy 해시태그!
그것에 대해 블로그에 올려주세요!
이웃의 울타리에 페인트를 뿌리지 마세요(친절하게 요청하지도 않고)!
마구 자르기!
이 작업을 수행:
1. 만들기 가상 환경:
$ virtualenv venv
활성화하세요.
$ . venv/bin/활성화
또는 사용 가상 환경 래퍼 가상 환경을 생성하고 관리하려면:
$ mkvirtualenv 하이
$ workon hy
2. 소스 코드를 얻으세요:
$ 자식 클론 https://github.com/hylang/hy.git
또는 포크를 사용하세요:
$ 자식 클론 [이메일 보호]: /hy.git
3. 해킹을 위해 설치:
$ CD HY/
$ 핍 설치 -e .
4. 기타 개발 요구 사항을 설치합니다.
$ pip 설치 -r 요구사항-dev.txt
5. 멋진 일을 하세요. 당신이 한 일에 대해 누군가가 기쁨/혐오감으로 비명을 지르게 만들 수 있습니다.
테스트!
시험 장소는 다음과 같습니다. 테스트 /. 우리는 사용 코.
테스트를 실행하려면 :
$ 코 테스트
테스트 작성---테스트는 좋습니다!
또한 지원되는 모든 플랫폼과 PEP 8 호환에 대해 테스트를 실행하는 것이 좋습니다.
암호. tox를 실행하면 됩니다:
$톡스
문서!
설명서는 다음 위치에 있습니다. docs /. 우리는 사용 스핑크스.
HTML로 문서를 작성하려면:
$ CD 문서
$ HTML 만들기
문서 작성---문서는 좋습니다! 심지어 이 문서도요!
기여
기여를 환영하며 크게 감사드립니다. 작은 것 하나하나가 Hy를 더욱 발전시키는 데 도움이 됩니다.
대단해
풀 리퀘스트는 훌륭합니다! 우리는 그들을 사랑합니다. 빠른 가이드는 다음과 같습니다.
· 저장소를 포크하고 기능/수정을 위한 주제 분기를 만듭니다. 직접 변경하지 마세요.
마스터 브랜치에서.
· 들어오는 모든 기능에는 테스트가 수반되어야 합니다.
· PR을 제출하기 전에 테스트를 실행하고 스타일과 비교하여 코드를 확인하세요.
가이드. 다음 두 가지 작업을 동시에 수행할 수 있습니다.
$ d를 만들다
· 나중에 추적하고 탐색하기가 더 쉽도록 커밋을 논리 단위로 만듭니다. 전에
PR을 제출할 때 다시 쉽게 돌아올 수 있도록 커밋을 변경 세트로 압축해 보세요.
나중에. 또한 변경 세트에 가짜 공백을 두지 않도록 하세요. 이것
나중에 공백 수정 커밋 생성을 방지합니다.
· 커밋 메시지에 관한 한 다음을 준수하도록 노력하세요.
· Git 커밋 메시지의 첫 번째 줄에 50자 제한을 지켜보세요.
· 더 자세한 내용/설명을 보려면 빈 줄을 입력하고 계속하세요.
커밋을 자세히 설명합니다.
· 마지막으로 AUTHORS 파일에 자신을 추가합니다(별도의 커밋으로): 그럴 자격이 있습니다 :)
· 들어오는 모든 변경 사항은 Hylang 핵심 팀의 다른 구성원 2명의 승인을 받아야 합니다.
추가 검토를 환영하지만 모든 검토에 대해 최소 2번의 승인이 필요합니다.
변경합니다.
· 핵심멤버가 PR을 보내는 경우, 포함되지 않은 핵심멤버 2명을 찾아주세요.
PR 제출자. 여기서의 아이디어는 한 사람이 PR 작성자와 작업할 수 있고 두 번째는 승인을 받을 수 있다는 것입니다.
전체 변경 세트.
· 문서화 및 기타 사소한 변경 사항의 경우 하나의 ACK 후에 병합하는 것이 좋습니다. 우리는있어
적용 범위가 낮으므로 장벽을 낮게 유지하는 것이 좋습니다.
핵심 함께 한다면
Hy의 핵심 개발팀은 다음 개발자로 구성됩니다.
· 줄리안 단주
· 모르 텐 린데루드
· J 케네스 왕
· Gergely 나기
· 투카 투르토
· 카렌어 루스타드
· Abhishek L
· 크리스토퍼 앨런 웨버
· 콘라드 힌센
· 의지 칸-그린
· 폴 탈리아몬테
· 니콜라스 단드리몬트
· 단발 톨버트
· BERKER 펙삭
· 클린턴 N. 드라이스바흐
· 한 세마즈
onworks.net 서비스를 사용하여 온라인으로 사용하세요.
