Yaltik/hy
2
0
Fork 0
Code Pull Requests Releases Activity

Merge branch 'master' into pr/579

Browse Source
This commit is contained in:
Paul Tagliamonte 2014-11-15 08:02:41 -05:00
commit b92c19c73c
56 changed files with 1458 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.dockerignore Normal file
View File

@ -0,0 +1 @@
.git

11
.mailmap Normal file
View File

@ -0,0 +1,11 @@
Paul R. Tagliamonte <paultag@debian.org> Paul Tagliamonte <paultag@debian.org>
Paul R. Tagliamonte <paultag@debian.org> Paul Tagliamonte <tag@pault.ag>
Paul R. Tagliamonte <paultag@debian.org> Paul Tagliamonte <paultag@sunlightfoundation.com>
Paul R. Tagliamonte <paultag@debian.org> Paul Tagliamonte <paultag@ubuntu.com>
Morten Linderud <morten@linderud.pw> Foxboron <morten@linderud.pw>
James King <james@agentultra.com> agentultra <james@agentultra.com>
James King <james@agentultra.com> J Kenneth King <james@agentultra.com>
Abhishek L <abhishek.lekshmanan@gmail.com> <abhishekl.2006@gmail.com>
Bob Tolbert <bob@tolbert.org> Bob Tolbert <bob@eyesopen.com>
Guillermo Vaya <guivaya@gmail.com> Guillermo Vaya <guillermo.vaya@gigas.com>
Gergely Nagy <algernon@balabit.hu> Gergely Nagy <algernon@madhouse-project.org>

10
.travis.yml
View File

@ -6,15 +6,11 @@ python:
- "3.2"
- "3.3"
- "3.4"
# command to install dependencies
install:
- pip install -r requirements-dev.txt
- pip install coveralls
- if [[ $TRAVIS_PYTHON_VERSION == '2.6' ]]; then pip install unittest2; fi # needs for running tests
- pip install --allow-all-external -e .
cache:
- $HOME/.pip-cache
# command to run tests
script: make travis
after_success: coveralls
after_success: make coveralls
notifications:
email:
- paultag@gmail.com

7
AUTHORS
View File

@ -42,7 +42,12 @@
* Halit Alptekin <info@halitalptekin.com>
* Richard Parsons <richard.lee.parsons@gmail.com>
* han semaj <sangho.nah@gmail.com>
* kirbyfan64 <kirbyfan64@users.noreply.github.com>
* Ryan Gonzalez <rymg19@gmail.com>
* Brendan Curran-Johnson <brendan@bcjbcj.ca>
* Ivan Kozik <ivan@ludios.org>
* Allison Kaptur <allison.kaptur@gmail.com>
* Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
* Tianon Gravi <admwiggin@gmail.com>
* Ian Denhardt <ian@zenhack.net>
* Ruslan Prokopiev <bismigalis@gmail.com>
* Alexander Artemenko <svetlyak.40wt@gmail.com>

44
CONTRIBUTING.rst Normal file
View File

@ -0,0 +1,44 @@
Contributions are welcome & greatly appreciated, every little bit
helps in making Hy more awesome.
Pull requests are great! We love them, here is a quick guide:
- Fork the repo, create a topic branch for a feature/fix. Avoid
making changes directly on the master branch
- All incoming features should be accompanied with tests
- Before you submit a PR, please run the tests and check your code
against the style guide. You can do both these things at once::
$ make d
- Make commits into logical units, so that it is easier to track &
navigate later. Before submitting a PR, try squashing the commits
into changesets that are easy to come back to later. Also make sure
you don't leave spurious whitespace in the changesets, this avoids
creation of whitespace fix commits later.
- As far as commit messages go, try to adhere to
the following:
+ Try sticking to the 50 character limit for the first line of git
commit messages
+ For more explanations etc. follow this up with a blank line and
continue describing the commit in detail
- Finally add yourself to the AUTHORS file (as a separate commit), you
deserve it :)
- All incoming changes need to be acked by 2 different members of
Hylang's core team. Additional review is clearly welcome, but we need
a minimum of 2 signoffs for any change.
- If a core member is sending in a PR, please find 2 core members that doesn't
include the PR submitter. The idea here is that one can work with the PR
author, and a second acks the entire change set.
- For documentation & other trivial changes, we're good to merge after one
ACK. We've got low coverage, so it'd be great to keep that barrier low.

10
Dockerfile Normal file
View File

@ -0,0 +1,10 @@
# Base image
#
# VERSION 0.2
FROM python:3
MAINTAINER Paul R. Tagliamonte <paultag@debian.org>
ADD . /opt/hylang/hy
RUN pip3 install -e /opt/hylang/hy
CMD ["hy"]

50
Makefile
View File

@ -1,3 +1,21 @@
pypy_url=http://buildbot.pypy.org/nightly/trunk/pypy-c-jit-latest-linux64.tar.bz2
pip_url=https://bootstrap.pypa.io/get-pip.py
python=python
pip=pip
coveralls=coveralls
nose=nosetests
pcache=$(HOME)/.pip-cache
ifeq (PyPy 2.4,$(findstring PyPy 2.4,$(shell python -V 2>&1 | tail -1)))
bad_pypy=1
python=./pypy
pip=./pip
coveralls=./coveralls
nose=./nosetests
else
bad_pypy=
endif
all:
@echo "No default step. Use setup.py"
@echo ""
@ -53,14 +71,42 @@ diff:
r: d tox diff
travis:
nosetests -s --with-coverage --cover-package hy
python:
ifeq ($(bad_pypy),1)
# Due to stupid PyPy 2.4 bugs, a custom version needs to be downloaded
curl $(pypy_url) -o pypy.tbz2
tar xf pypy.tbz2
ln -sf `pwd`/pypy-*/bin/pypy $(python)
curl $(pip_url) | $(python)
ln -sf `pwd`/pypy-*/bin/pip $(pip)
sudo $(pip) install nose
ln -sf `pwd`/pypy-*/bin/nosetests $(nose)
endif
ifeq (Python 2.6,$(findstring Python 2.6,$(shell python -V 2>&1)))
$(pip) install unittest2
endif
$(pip) install -r requirements-travis.txt --download-cache $(pcache)
$(pip) install coveralls --download-cache $(pcache)
$(pip) install --allow-all-external -e .
ifeq ($(bad_pypy),1)
ln -sf `pwd`/pypy-*/bin/coveralls $(coveralls)
endif
travis: python
ifeq ($(bad_pypy),1)
HY_DIR=`pwd`/pypy-*/bin $(nose) -s --with-coverage --cover-package hy
else
$(nose) -s --with-coverage --cover-package hy
endif
ifeq (PyPy,$(findstring PyPy,$(shell python -V 2>&1 | tail -1)))
@echo "skipping flake8 on pypy"
else
flake8 hy bin tests
endif
coveralls:
$(coveralls)
clean:
@find . -name "*.pyc" -exec rm {} \;
@find -name __pycache__ -delete

58
NEWS
View File

@ -1,3 +1,49 @@
Changes from 0.10.0
This release took some time (sorry, all my fault) but it's got a bunch of
really nice features. We hope you enjoy hacking with Hy as much as we enjoy
hacking on Hy.
In other news, we're Dockerized as an official library image!
<https://registry.hub.docker.com/_/hylang/>
$ docker run -it --rm hylang
hy 0.10.0 using CPython(default) 3.4.1 on Linux
=> ((lambda [] (print "Hello, World!")))
Hello, World!
- Hy Society
[ Language Changes ]
* Implement raise :from, Python 3 only.
* defmain macro
* name & keyword functions added to core
* (read) added to core
* shadow added to core
* New functions interleave interpose zip_longest added to core
* nth returns default value when out of bounds
* merge-with added
* doto macro added
* keyword? to findout keywords
* setv no longer allows "." in names
[Internals ]
* Builtins reimplemented in terms of python stdlib
* gensyms (defmacro/g!) handles non-string types better
[Tools]
* Added hy2py to installed scripts
[ Misc. Fixes ]
* Symbols like true, false, none can't be assigned
* Set sys.argv default to [''] like Python does
* REPL displays the the python version and platform at startup
* Dockerfile added for https://registry.hub.docker.com/_/hylang/
[ Contrib changes ]
* Fix ap-first and ap-last for failure conditions
Changes from 0.9.12
0.10.0 - the "oh man I'm late for PyCon" release
@ -60,7 +106,7 @@ Changes from 0.9.12
* "clean" target added to Makefile
* hy2py supports a bunch of commandline options to show AST, source etc.
* Sub-object mangling: every identifier is split along the dots & mangled
seperately
separately
[ Bug Fixes ]
* Empty MacroExpansions work as expected
@ -88,7 +134,7 @@ Changes from Hy 0.9.11
what exactly was added.
The biggest feature, Reader Macros, landed later
in the cycle, but were big enough to warrent a release on it's
in the cycle, but were big enough to warrant a release on its
own. A huge thanks goes to Foxboron for implementing them
and a massive hug goes out to olasd for providing ongoing
reviews during the development.
@ -267,7 +313,7 @@ Changes from Hy 0.9.6
* UTF-8 encoded hy symbols are now hy_... rather than __hy_..., it's
silly to prefex them as such. (PT)
* `j' is no longer always intepreted as a complex number; we use it much
* `j' is no longer always interpreted as a complex number; we use it much
more as a symbol. (ND)
* (decorate-with) has been moved to (with-decorate) (JD)
* New (unless) macro (JD)
@ -286,7 +332,7 @@ Changes from Hy 0.9.6
and jd for making this happen. This solves just an insane number
of bugs. (ND, PT, JD)
* Eval no longer sucks with statements (ND)
* New magic binary flags / mis fixes with the hy intepreter
* New magic binary flags / mis fixes with the hy interpreter
(WKG + @eigenhombre)
@ -311,7 +357,7 @@ Changes from Hy 0.9.5
=============== WARNING: WARNING: READ ME: READ ME: ===================
From here on out, we will only support "future division" as part of hy.
This is actually quite a pain for us, but it's going to be quite an
amazing feautre.
amazing feature.
This also normalizes behavior from Py 2 --> Py 3.
@ -346,7 +392,7 @@ Changes from Hy 0.9.4
* Statements in the `fn' path early will not return anymore. (PT)
* Added "not" as the inline "not" operator. It's advised to still
use "not-in" or "is-not" rather then nesting. (JD)
use "not-in" or "is-not" rather than nesting. (JD)
* `let' macro added (PT)
* Added "~" as the "invert" operator. (JD)
* `catch' now accepts a new format: (JD)

2
README.md
View File

@ -25,7 +25,7 @@ OK, so, why?
------------
Well. Python is awesome. So awesome, that we have so many tools to alter the
languge in a *core* way, but we never use them.
language in a *core* way, but we never use them.
Why?

12
docs/contrib/multi.rst
View File

@ -11,13 +11,13 @@ args and/or kwargs. Inspired by clojures take on `defn`.
=> (require hy.contrib.multi)
=> (defmulti fun
... ([a] a)
... ([a] "a")
... ([a b] "a b")
... ([a b c] "a b c"))
=> (fun 1 2 3)
'a b c'
=> (fun a b)
"a b"
=> (fun 1)
1
"a"
=> (fun 1 2)
"a b"
=> (fun 1 2 3)
"a b c"

1
docs/coreteam.rst
View File

@ -13,3 +13,4 @@
* `Bob Tolbert <https://github.com/rwtolbert>`_
* `Berker Peksag <https://github.com/berkerpeksag>`_
* `Clinton N. Dreisbach <https://github.com/cndreisbach>`_
* `han semaj <https://github.com/microamp>`_

22
docs/hacking.rst
View File

@ -89,26 +89,10 @@ To build the docs in HTML::
Write docs---docs are good! Even this doc!
Core Development Rules
======================
Pull requests are good!
Before you submit a PR, please run the tests and check your code against the style guide. You can do both these things at once::
$ make d
All incoming changes need to be acked by 2 different members of Hylang's
core team. Additional review is clearly welcome, but we need a minimum of
2 signoffs for any change.
If a core member is sending in a PR, please find 2 core members that don't
include the PR submitter. The idea here is that one can work with the PR
author, and a second acks the entire change set.
If the change is adding documentation, feel free to just merge after one
ACK. We've got low coverage, so it'd be great to keep that barrier low.
Contributing
============
.. include:: ../CONTRIBUTING.rst
Core Team
=========

179
docs/language/api.rst
View File

@ -271,6 +271,21 @@ however is called only for every other value in the list.
(side-effect2 x)))
dict-comp
---------
`dict-comp` is used to create dictionaries. It takes three or four parameters.
The first two parameters are for controlling the return value
(key-value pair), while the third is used to select items from a sequence. The
fourth and optional parameter can be used to filter out some of the items in
the sequence based on a conditional expression.
.. code-block:: hy
=> (dict-comp x (* x 2) [x (range 10)] (odd? x))
{1: 2, 3: 6, 9: 18, 5: 10, 7: 14}
do / progn
----------
@ -290,7 +305,7 @@ Some example usage:
Yeah, really!
;; assuming that (side-effect) is a function that we want to call for each
;; and every value in the list, but which return values we do not care
;; and every value in the list, but whose return value we do not care about
=> (list-comp (do (side-effect x)
... (if (< x 5) (* 2 x)
... (* 4 x)))
@ -401,7 +416,7 @@ Parameters may have following keywords in front of them:
arguments may be specified after this one.
The following code example defines a function that can be given 0 to n
numerical parameters. It then sums every odd number and substracts
numerical parameters. It then sums every odd number and subtracts
every even number.
.. code-block:: clj
@ -441,6 +456,44 @@ symbols for function names as the first parameter, `defn-alias` and
=> (alias)
"Hello!"
defmain
-------
.. versionadded:: 0.10.1
The `defmain` macro defines a main function that is immediately called
with sys.argv as arguments if and only if this file is being executed
as a script. In other words this:
.. code-block:: clj
(defmain [&rest args]
(do-something-with args))
is the equivalent of::
def main(*args):
do_something_with(args)
return 0
if __name__ == "__main__":
import sys
retval = main(*sys.arg)
if isinstance(retval, int):
sys.exit(retval)
Note, as you can see above, if you return an integer from this
function, this will be used as the exit status for your script.
(Python defaults to exit status 0 otherwise, which means everything's
okay!)
(Since (sys.exit 0) is not run explicitly in case of a non-integer
return from defmain, it's good to put (defmain) as the last bit of
code in your file.)
.. _defmacro:
defmacro
@ -560,6 +613,27 @@ del
=> dic
{}
doto
----
.. versionadded:: 0.10.1
`doto` macro is used to make a sequence of method calls for an object easy.
.. code-block:: clj
=> (doto [] (.append 1) (.append 2) .reverse)
[2 1]
.. code-block:: clj
=> (setv collection [])
=> (.append collection 1)
=> (.append collection 2)
=> (.reverse collection)
=> collection
[2 1]
eval
----
@ -629,6 +703,24 @@ normally. If the execution is halted with `break`, the `else` does not execute.
loop finished
genexpr
-------
`genexpr` is used to create generator expressions. It takes two or three parameters.
The first parameter is the expression controlling the return value, while
the second is used to select items from a list. The third and optional
parameter can be used to filter out some of the items in the list based on a
conditional expression. `genexpr` is similar to `list-comp`, except that it returns
an iterable that evaluates values one by one instead of evaluating them immediately.
.. code-block:: hy
=> (def collection (range 10))
=> (def filtered (genexpr x [x collection] (even? x)))
=> (list filtered)
[0, 2, 4, 6, 8]
.. _gensym:
gensym
@ -726,14 +818,18 @@ any numeric type, empty sequence and empty dictionary are considered `False`.
Everything else is considered `True`.
lisp-if / lif
-------------
lisp-if / lif and lisp-if-not / lif-not
---------------------------------------
.. versionadded:: 0.10.0
.. versionadded:: 0.10.2
lisp-if-not / lif-not
For those that prefer a more lisp-y if clause, we have lisp-if, or lif. This
*only* considers None/nil as false! All other values of python
"falseiness" are considered true.
"falseiness" are considered true. Conversely, we have lisp-if-not or lif-not,
in parallel to if / if-not, which reverses the comparison.
.. code-block:: clj
@ -748,12 +844,20 @@ For those that prefer a more lisp-y if clause, we have lisp-if, or lif. This
"false"
=> (lisp-if None "true" "false")
"false"
=> (lisp-if-not nil "true" "false")
"true"
=> (lisp-if-not None "true" "false")
"true"
=> (lisp-if-not False "true" "false")
"false"
; And, same thing
=> (lif True "true" "false")
"true"
=> (lif nil "true" "false")
"false"
=> (lif-not None "true" "false")
"true"
import
@ -1003,6 +1107,22 @@ element:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
set-comp
--------
`set-comp` is used to create sets. It takes two or three parameters.
The first parameter is for controlling the return value, while the second is
used to select items from a sequence. The third and optional parameter can be
used to filter out some of the items in the sequence based on a conditional
expression.
.. code-block:: hy
=> (setv data [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x data] (odd? x))
{1, 3, 5}
slice
-----
@ -1057,7 +1177,7 @@ Example usage
; Throw an IOError("foobar")
`throw` can acccept a single argument (an `Exception` class or instance), or
`throw` can accept a single argument (an `Exception` class or instance), or
no arguments to re-raise the last Exception.
@ -1151,7 +1271,7 @@ while
`while` form is used to execute a single or more blocks as long as a condition
is being met.
The following example will output "hello world!" on screen indefinetely:
The following example will output "hello world!" on screen indefinitely:
.. code-block:: clj
@ -1185,23 +1305,48 @@ file is automatically closed after it has been processed.
with-decorator
--------------
`with-decorator` is used to wrap a function with another. The function performing
decoration should accept a single value, the function being decorated and return
a new function. `with-decorator` takes two parameters, the function performing
decoration and the function being decorated.
In the following example, `inc-decorator` is used to decorate function `addition`
with a function that takes two parameters and calls the decorated function with
values that are incremented by 1. When decorated `addition` is called with values
1 and 1, the end result will be 4 (1+1 + 1+1).
`with-decorator` is used to wrap a function with another. The function
performing decoration should accept a single value, the function being
decorated and return a new function. `with-decorator` takes a minimum
of two parameters, the function performing decoration and the function
being decorated. More than one decorator function can be applied, they
will be applied in order from outermost to innermost, ie. the first
decorator will be the outermost one & so on. Decorators with arguments
are called just like a function call.
.. code-block:: clj
=> (defn inc-decorator [func]
(with-decorator decorator-fun
(defn some-function [] ...)
(with-decorator decorator1 decorator2 ...
(defn some-function [] ...)
(with-decorator (decorator arg) ..
(defn some-function [] ...)
In the following example, `inc-decorator` is used to decorate function
`addition` with a function that takes two parameters and calls the
decorated function with values that are incremented by 1. When
decorated `addition` is called with values 1 and 1, the end result
will be 4 (1+1 + 1+1).
.. code-block:: clj
=> (defn inc-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 1) (+ value-2 1))))
=> (defn inc2-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 2) (+ value-2 2))))
=> (with-decorator inc-decorator (defn addition [a b] (+ a b)))
=> (addition 1 1)
4
=> (with-decorator inc2-decorator inc-decorator
... (defn addition [a b] (+ a b)))
=> (addition 1 1)
8
.. _with-gensyms:

200
docs/language/core.rst
View File

@ -6,6 +6,31 @@ Hy Core
Core Functions
===============
.. _butlast-fn:
butlast
-------
Usage: ``(butlast coll)``
Returns an iterator of all but the last item in ``coll``.
.. code-block:: hy
=> (list (butlast (range 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]
=> (list (butlast [1]))
[]
=> (list (butlast []))
[]
=> (import itertools)
=> (list (take 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]
.. _is-coll-fn:
coll?
@ -290,6 +315,46 @@ either ``int`` or ``long``. For Python 3, this is ``int``.
False
.. _interleave-fn:
interleave
----------
.. versionadded:: 0.10.1
Usage: ``(interleave seq1 seq2 ...)``
Return an iterable of the first item in each of the sequences, then the second etc.
.. code-block:: hy
=> (list (interleave (range 5) (range 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]
=> (list (interleave (range 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']
.. _interpose-fn:
interpose
---------
.. versionadded:: 0.10.1
Usage: ``(interpose item seq)``
Return an iterable of the elements of the sequence separated by the item.
.. code-block:: hy
=> (list (interpose "!" "abcd"))
['a', '!', 'b', '!', 'c', '!', 'd']
=> (list (interpose -1 (range 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]
.. _iterable?-fn:
iterable?
@ -409,6 +474,27 @@ Returns the single step macro expansion of form.
=> (macroexpand-1 '(-> (a b) (-> (c d) (e f))))
(u'_>' (u'a' u'b') (u'c' u'd') (u'e' u'f'))
.. _merge-with-fn:
merge-with
----------
.. versionadded:: 0.10.1
Usage: ``(merge-with f &rest maps)
Returns a map that consist of the rest of the maps joined onto first.
If a key occurs in more than one map, the mapping(s) from the latter
(left-to-right) will be combined with the mapping in the result by
calling ``(f val-in-result val-in-latter)``.
.. code-block:: clojure
=> (merge-with (fn [x y] (+ x y)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a': 11L, u'c': 30L, u'b': 20L}
.. _neg?-fn:
neg?
@ -492,11 +578,11 @@ Return True if x is None.
nth
---
Usage: ``(nth coll n)``
Usage: ``(nth coll n &optional [default nil])``
Return the `nth` item in a collection, counting from 0. Unlike
``get``, ``nth`` works on both iterators and iterables. Raises ``IndexError``
if the `n` is outside the range of ``coll`` or ``ValueError`` if it's negative.
Return the `nth` item in a collection, counting from 0. Return the
default value, ``nil``, if out of bounds (unless specified otherwise).
Raise ``ValueError`` if ``n`` is negative.
.. code-block:: hy
@ -506,14 +592,21 @@ if the `n` is outside the range of ``coll`` or ``ValueError`` if it's negative.
=> (nth [1 2 4 7] 3)
7
=> (nth [1 2 4 7] 5)
Traceback (most recent call last):
...
IndexError: 5
=> (nil? (nth [1 2 4 7] 5))
True
=> (nth [1 2 4 7] 5 "default")
'default'
=> (nth (take 3 (drop 2 [1 2 3 4 5 6])) 2))
5
=> (nth [1 2 4 7] -1)
Traceback (most recent call last):
...
ValueError: Indices for islice() must be None or an integer: 0 <= x <= sys.maxsize.
.. _numeric?-fn:
numeric?
@ -607,21 +700,25 @@ some
Usage: ``(some pred coll)``
Return True if ``(pred x)`` is logical true for any ``x`` in ``coll``, otherwise False. Return False if ``coll`` is empty.
Return the first logical true value of ``(pred x)`` for any ``x`` in
``coll``, otherwise ``nil``. Return ``nil`` if ``coll`` is empty.
.. code-block:: hy
=> (some even? [2 4 6])
True
=> (some even? [1 3 5])
False
=> (some even? [1 3 6])
=> (nil? (some even? [1 3 5]))
True
=> (some even? [])
False
=> (nil? (some identity [0 "" []]))
True
=> (some identity [0 "non-empty-string" []])
'non-empty-string'
=> (nil? (some even? []))
True
.. _string?-fn:
@ -782,6 +879,32 @@ Raises ``ValueError`` if ``n`` is negative.
=> (list (drop 6 [1 2 3 4 5]))
[]
.. _drop-last-fn:
drop-last
---------
Usage: ``(drop-last n coll)``
Return an iterator of all but the last ``n`` items in ``coll``. Raise ``ValueError`` if ``n`` is negative.
.. code-block:: hy
=> (list (drop-last 5 (range 10 20)))
[10, 11, 12, 13, 14]
=> (list (drop-last 0 (range 5)))
[0, 1, 2, 3, 4]
=> (list (drop-last 100 (range 100)))
[]
=> (import itertools)
=> (list (take 5 (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]
.. _drop-while-fn:
drop-while
@ -862,6 +985,53 @@ Return an iterator of `x`, `fn(x)`, `fn(fn(x))`.
[5, 25, 625, 390625, 152587890625]
.. _read-fn:
read
----
Usage: ``(read &optional [from-file eof])``
Reads the next hy expression from `from-file` (defaults to `sys.stdin`), and
can take a single byte as EOF (defaults to an empty string).
Raises an `EOFError` if `from-file` ends before a complete expression can be
parsed.
.. code-block:: hy
=> (read)
(+ 2 2)
('+' 2 2)
=> (eval (read))
(+ 2 2)
4
=> (import io)
=> (def buffer (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (apply read [] {"from_file" buffer}))
4
=> (eval (apply read [] {"from_file" buffer}))
1
=> ; assuming "example.hy" contains:
=> ; (print "hello")
=> ; (print "hyfriends!")
=> (with [[f (open "example.hy")]]
... (try
... (while true
... (let [[exp (read f)]]
... (do
... (print "OHY" exp)
... (eval exp))))
... (catch [e EOFError]
... (print "EOF!"))))
OHY ('print' 'hello')
hello
OHY ('print' 'hyfriends!')
hyfriends!
EOF!
.. _remove-fn:
remove

2
docs/language/internals.rst
View File

@ -387,7 +387,7 @@ for a more complete description.) ``nif`` is an example, something like a numeri
where based on the expression, one of the 3 forms is called depending on if the
expression is positive, zero or negative.
A first pass might be someting like:
A first pass might be something like:
.. code-block:: hy

2
docs/language/readermacros.rst
View File

@ -70,4 +70,4 @@ and expression is passed to the correct function.
.. warning::
Because of a limitation in Hy's lexer and parser, reader macros can't
redefine defined syntax such as ``()[]{}``. This will most likely be
adressed in the future.
addressed in the future.

2
docs/tutorial.rst
View File

@ -500,7 +500,7 @@ Let's take the classic:
(loop (print (eval (read))))
Rather then write it like that, we can write it as follows:
Rather than write it like that, we can write it as follows:
.. code-block:: clj

2
eg/sunlight/party-count.hy
View File

@ -1,6 +1,6 @@
#!/usr/bin/env hy
;; Copyright (c) Paul R. Tagliamonte <paultag@debian.org>, 2013 under the terms
;; of the Expat license, a copy of which you have should have recieved with
;; of the Expat license, a copy of which you should have received with
;; the source.
(import sys)

1
hy/__init__.py
View File

@ -23,7 +23,6 @@ from hy.version import __version__, __appname__ # NOQA
from hy.models.expression import HyExpression # NOQA
from hy.models.lambdalist import HyLambdaListKeyword # NOQA
from hy.models.integer import HyInteger # NOQA
from hy.models.keyword import HyKeyword # NOQA
from hy.models.complex import HyComplex # NOQA

2
hy/__main__.py
View File

@ -23,7 +23,7 @@ import imp
import sys
# This just mocks the normalish behavior of the Python interp. Helpful to aid
# with shiming existing apps that don't really "work" with Hy.
# with shimming existing apps that don't really "work" with Hy.
#
# You could say this script helps Hyjack a file.
#

6
hy/_compat.py
View File

@ -52,3 +52,9 @@ if PY3:
long_type = int
else:
long_type = long # NOQA
if PY3:
exec('def raise_empty(t, *args): raise t(*args) from None')
else:
def raise_empty(t, *args):
raise t(*args)

48
hy/cmdline.py
View File

@ -47,7 +47,7 @@ from hy.models.expression import HyExpression
from hy.models.string import HyString
from hy.models.symbol import HySymbol
from hy._compat import builtins
from hy._compat import builtins, PY3
class HyQuitter(object):
@ -203,6 +203,7 @@ def run_file(filename):
def run_repl(hr=None, spy=False):
import platform
sys.ps1 = "=> "
sys.ps2 = "... "
@ -210,10 +211,15 @@ def run_repl(hr=None, spy=False):
if not hr:
hr = HyREPL(spy)
hr.interact("{appname} {version}".format(
appname=hy.__appname__,
version=hy.__version__
))
hr.interact("{appname} {version} using "
"{py}({build}) {pyversion} on {os}".format(
appname=hy.__appname__,
version=hy.__version__,
py=platform.python_implementation(),
build=platform.python_build()[0],
pyversion=platform.python_version(),
os=platform.system()
))
return 0
@ -321,6 +327,7 @@ def hyc_main():
# entry point for cmd line script "hy2py"
def hy2py_main():
import platform
module_name = "<STDIN>"
options = dict(prog="hy2py", usage="%(prog)s [options] FILE",
@ -343,17 +350,42 @@ def hy2py_main():
if options.with_source:
hst = import_file_to_hst(options.args[0])
print(hst)
# need special printing on Windows in case the
# codepage doesn't support utf-8 characters
if PY3 and platform.system() == "Windows":
for h in hst:
try:
print(h)
except:
print(str(h).encode('utf-8'))
else:
print(hst)
print()
print()
_ast = import_file_to_ast(options.args[0], module_name)
if options.with_ast:
print(astor.dump(_ast))
if PY3 and platform.system() == "Windows":
_print_for_windows(astor.dump(_ast))
else:
print(astor.dump(_ast))
print()
print()
if not options.without_python:
print(astor.codegen.to_source(_ast))
if PY3 and platform.system() == "Windows":
_print_for_windows(astor.codegen.to_source(_ast))
else:
print(astor.codegen.to_source(_ast))
parser.exit(0)
# need special printing on Windows in case the
# codepage doesn't support utf-8 characters
def _print_for_windows(src):
for line in src.split("\n"):
try:
print(line)
except:
print(line.encode('utf-8'))

103
hy/compiler.py
View File

@ -1,10 +1,10 @@
# -*- encoding: utf-8 -*-
#
# Copyright (c) 2013 Paul Tagliamonte <paultag@debian.org>
# Copyright (c) 2013, 2014 Paul Tagliamonte <paultag@debian.org>
# Copyright (c) 2013 Julien Danjou <julien@danjou.info>
# Copyright (c) 2013 Nicolas Dandrimont <nicolas.dandrimont@crans.org>
# Copyright (c) 2013 James King <james@agentultra.com>
# Copyright (c) 2013 Bob Tolbert <bob@tolbert.org>
# Copyright (c) 2013, 2014 Bob Tolbert <bob@tolbert.org>
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
@ -24,7 +24,6 @@
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
from hy.models.lambdalist import HyLambdaListKeyword
from hy.models.expression import HyExpression
from hy.models.keyword import HyKeyword
from hy.models.integer import HyInteger
@ -39,7 +38,7 @@ from hy.models.cons import HyCons
from hy.errors import HyCompileError, HyTypeError
import hy.macros
from hy._compat import str_type, long_type, PY27, PY33, PY3, PY34
from hy._compat import str_type, long_type, PY27, PY33, PY3, PY34, raise_empty
from hy.macros import require, macroexpand, reader_macroexpand
import hy.importer
@ -48,6 +47,7 @@ import importlib
import codecs
import ast
import sys
import keyword
from collections import defaultdict
@ -74,6 +74,21 @@ def load_stdlib():
_stdlib[e] = module
# True, False and None included here since they
# are assignable in Python 2.* but become
# keywords in Python 3.*
def _is_hy_builtin(name, module_name):
extras = ['True', 'False', 'None',
'true', 'false', 'nil', 'null']
if name in extras or keyword.iskeyword(name):
return True
# for non-Hy modules, check for pre-existing name in
# _compile_table
if not module_name.startswith("hy."):
return name in _compile_table
return False
_compile_table = {}
@ -305,13 +320,12 @@ def _raise_wrong_args_number(expression, error):
len(expression)))
def checkargs(exact=None, min=None, max=None, even=None):
def checkargs(exact=None, min=None, max=None, even=None, multiple=None):
def _dec(fn):
def checker(self, expression):
if exact is not None and (len(expression) - 1) != exact:
_raise_wrong_args_number(
expression, "`%%s' needs %d arguments, got %%d" % exact)
if min is not None and (len(expression) - 1) < min:
_raise_wrong_args_number(
expression,
@ -330,6 +344,14 @@ def checkargs(exact=None, min=None, max=None, even=None):
"`%%s' needs an %s number of arguments, got %%d"
% (even_str))
if multiple is not None:
if not (len(expression) - 1) in multiple:
choices = ", ".join([str(val) for val in multiple[:-1]])
choices += " or %s" % multiple[-1]
_raise_wrong_args_number(
expression,
"`%%s' needs %s arguments, got %%d" % choices)
return fn(self, expression)
return checker
@ -407,7 +429,7 @@ class HyASTCompiler(object):
except HyTypeError as e:
raise
except Exception as e:
raise HyCompileError(e, sys.exc_info()[2])
raise_empty(HyCompileError, e, sys.exc_info()[2])
raise HyCompileError(Exception("Unknown type: `%s'" % _type))
@ -430,6 +452,7 @@ class HyASTCompiler(object):
def _parse_lambda_list(self, exprs):
""" Return FunctionDef parameter values from lambda list."""
ll_keywords = ("&rest", "&optional", "&key", "&kwargs")
ret = Result()
args = []
defaults = []
@ -439,10 +462,7 @@ class HyASTCompiler(object):
for expr in exprs:
if isinstance(expr, HyLambdaListKeyword):
if expr not in expr._valid_types:
raise HyTypeError(expr, "{0} is not a valid "
"lambda-keyword.".format(repr(expr)))
if expr in ll_keywords:
if expr == "&rest" and lambda_keyword is None:
lambda_keyword = expr
elif expr == "&optional":
@ -616,7 +636,7 @@ class HyASTCompiler(object):
return imports, ret.replace(form), False
elif isinstance(form, (HySymbol, HyLambdaListKeyword)):
elif isinstance(form, HySymbol):
return imports, HyExpression([HySymbol(name),
HyString(form)]).replace(form), False
@ -665,13 +685,22 @@ class HyASTCompiler(object):
@builds("throw")
@builds("raise")
@checkargs(max=1)
@checkargs(multiple=[0, 1, 3])
def compile_throw_expression(self, expr):
expr.pop(0)
ret = Result()
if expr:
ret += self.compile(expr.pop(0))
cause = None
if len(expr) == 2 and expr[0] == HyKeyword(":from"):
if not PY3:
raise HyCompileError(
"raise from only supported in python 3")
expr.pop(0)
cause = self.compile(expr.pop(0))
cause = cause.expr
# Use ret.expr to get a literal `None`
ret += ast.Raise(
lineno=expr.start_line,
@ -680,7 +709,7 @@ class HyASTCompiler(object):
exc=ret.expr,
inst=None,
tback=None,
cause=None)
cause=cause)
return ret
@ -707,7 +736,8 @@ class HyASTCompiler(object):
lineno=expr.start_line,
col_offset=expr.start_column)
returnable = Result(expr=expr_name, temp_variables=[expr_name, name])
returnable = Result(expr=expr_name, temp_variables=[expr_name, name],
contains_yield=body.contains_yield)
body += ast.Assign(targets=[name],
value=body.force_expr,
@ -999,7 +1029,10 @@ class HyASTCompiler(object):
@checkargs(max=1)
def compile_yield_expression(self, expr):
expr.pop(0)
ret = Result(contains_yield=True)
if PY33:
ret = Result(contains_yield=False)
else:
ret = Result(contains_yield=True)
value = None
if expr != []:
@ -1235,7 +1268,8 @@ class HyASTCompiler(object):
def compile_decorate_expression(self, expr):
expr.pop(0) # with-decorator
fn = self.compile(expr.pop(-1))
if not fn.stmts or not isinstance(fn.stmts[-1], ast.FunctionDef):
if not fn.stmts or not (isinstance(fn.stmts[-1], ast.FunctionDef) or
isinstance(fn.stmts[-1], ast.ClassDef)):
raise HyTypeError(expr, "Decorated a non-function")
decorators, ret = self._compile_collect(expr)
fn.stmts[-1].decorator_list = decorators
@ -1512,7 +1546,7 @@ class HyASTCompiler(object):
def compile_require(self, expression):
"""
TODO: keep track of what we've imported in this run and then
"unimport" it after we've completed `thing' so that we don't polute
"unimport" it after we've completed `thing' so that we don't pollute
other envs.
"""
expression.pop(0)
@ -1750,19 +1784,26 @@ class HyASTCompiler(object):
def _compile_assign(self, name, result,
start_line, start_column):
str_name = "%s" % name
if _is_hy_builtin(str_name, self.module_name):
raise HyTypeError(name,
"Can't assign to a builtin: `%s'" % str_name)
result = self.compile(result)
if result.temp_variables and isinstance(name, HyString):
result.rename(name)
return result
ld_name = self.compile(name)
st_name = self._storeize(ld_name)
result += ast.Assign(
lineno=start_line,
col_offset=start_column,
targets=[st_name], value=result.force_expr)
if result.temp_variables \
and isinstance(name, HyString) \
and '.' not in name:
result.rename(name)
else:
st_name = self._storeize(ld_name)
result += ast.Assign(
lineno=start_line,
col_offset=start_column,
targets=[st_name],
value=result.force_expr)
result += ld_name
return result
@ -1855,7 +1896,7 @@ class HyASTCompiler(object):
ret, args, defaults, stararg, kwargs = self._parse_lambda_list(arglist)
if PY34:
# Python 3.4+ requres that args are an ast.arg object, rather
# Python 3.4+ requires that args are an ast.arg object, rather
# than an ast.Name or bare string.
args = [ast.arg(arg=ast_str(x),
annotation=None, # Fix me!
@ -1963,12 +2004,12 @@ class HyASTCompiler(object):
except TypeError:
raise HyTypeError(
expression,
"Wrong argument type for defclass slots definition.")
"Wrong argument type for defclass attributes definition.")
for b in body_expression:
if len(b) != 2:
raise HyTypeError(
expression,
"Wrong number of argument in defclass slot.")
"Wrong number of argument in defclass attribute.")
body += self._compile_assign(b[0], b[1],
b.start_line, b.start_column)
body += body.expr_as_stmt()

25
hy/contrib/anaphoric.hy
View File

@ -46,9 +46,10 @@
(defmacro ap-map [form lst]
"Yield elements evaluated in the form for each element in the list."
`(let [[f (lambda [it] ~form)]]
(for [v ~lst]
(yield (f v)))))
(let [[v (gensym 'v)] [f (gensym 'f)]]
`(let [[~f (lambda [it] ~form)]]
(for [~v ~lst]
(yield (~f ~v))))))
(defmacro ap-map-when [predfn rep lst]
@ -83,18 +84,20 @@
(defmacro ap-first [predfn lst]
"Yield the first element that passes `predfn`"
`(let [[n (gensym)]]
(ap-each ~lst (when ~predfn (setv n it) (break)))
n))
(with-gensyms [n]
`(let [[~n None]]
(ap-each ~lst (when ~predfn (setv ~n it) (break)))
~n)))
(defmacro ap-last [predfn lst]
"Yield the last element that passes `predfn`"
`(let [[n (gensym)]]
(ap-each ~lst (none? n)
(when ~predfn
(setv n it)))
n))
(with-gensyms [n]
`(let [[~n None]]
(ap-each ~lst (none? ~n)
(when ~predfn
(setv ~n it)))
~n)))
(defmacro ap-reduce [form lst &optional [initial-value None]]

3
hy/core/__init__.py
View File

@ -1,3 +1,4 @@
STDLIB = [
"hy.core.language"
"hy.core.language",
"hy.core.shadow"
]

138
hy/core/language.hy
View File

@ -26,14 +26,20 @@
(import itertools)
(import functools)
(import collections)
(import sys)
(import [hy._compat [long-type]]) ; long for python2, int for python3
(import [hy.models.cons [HyCons]])
(import [hy.models.cons [HyCons]]
[hy.models.keyword [HyKeyword *keyword-prefix*]])
(import [hy.lex [LexException PrematureEndOfInput tokenize]])
(defn _numeric-check [x]
(if (not (numeric? x))
(raise (TypeError (.format "{0!r} is not a number" x)))))
(defn butlast [coll]
"Returns coll except of last element."
(drop-last 1 coll))
(defn coll? [coll]
"Checks whether item is a collection"
(and (iterable? coll) (not (string? coll))))
@ -51,24 +57,23 @@
(and (instance? (type :foo) k)
(.startswith k (get :foo 0))))
(defn dec [n]
"Decrement n by 1"
(_numeric-check n)
(- n 1))
(defn disassemble [tree &optional [codegen false]]
"Dump the python AST for a given Hy tree to standard output
"Return the python AST for a quoted Hy tree as a string.
If the second argument is true, generate python code instead."
(import astor)
(import hy.compiler)
(fake-source-positions tree)
(setv compiled (hy.compiler.hy_compile tree (calling-module-name)))
(print ((if codegen
((if codegen
astor.codegen.to_source
astor.dump)
compiled)))
compiled))
(defn distinct [coll]
"Return a generator from the original collection with duplicates
@ -88,7 +93,8 @@
(setv map itertools.imap)
(setv zip itertools.izip)
(setv range xrange)
(setv input raw_input))
(setv input raw_input)
(setv reduce reduce))
(do
(setv reduce functools.reduce)
(setv filterfalse itertools.filterfalse)
@ -106,11 +112,18 @@
(setv drop-while itertools.dropwhile)
(setv take-while itertools.takewhile)
(setv zipwith map)
(setv remove filterfalse)
(defn drop [count coll]
"Drop `count` elements from `coll` and yield back the rest"
(itertools.islice coll count nil))
(defn drop-last [n coll]
"Return a sequence of all but the last n elements in coll."
(let [[iters (itertools.tee coll)]]
(map first (apply zip [(get iters 0)
(drop n (get iters 1))]))))
(defn empty? [coll]
"Return True if `coll` is empty"
(= 0 (len coll)))
@ -203,6 +216,14 @@
(catch [e ValueError] False)
(catch [e TypeError] False)))
(defn interleave [&rest seqs]
"Return an iterable of the first item in each of seqs, then the second etc."
(itertools.chain.from_iterable (apply zip seqs)))
(defn interpose [item seq]
"Return an iterable of the elements of seq separated by item"
(drop 1 (interleave (itertools.repeat item) seq)))
(defn iterable? [x]
"Return true if x is iterable"
(isinstance x collections.Iterable))
@ -237,6 +258,22 @@
(setv name (calling-module-name))
(hy.macros.macroexpand-1 form name))
(defn merge-with [f &rest maps]
"Returns a map that consists of the rest of the maps joined onto
the first. If a key occurs in more than one map, the mapping(s)
from the latter (left-to-right) will be combined with the mapping in
the result by calling (f val-in-result val-in-latter)."
(if (any maps)
(let [[merge-entry (fn [m e]
(let [[k (get e 0)] [v (get e 1)]]
(if (in k m)
(assoc m k (f (get m k) v))
(assoc m k v)))
m)]
[merge2 (fn [m1 m2]
(reduce merge-entry (.items m2) (or m1 {})))]]
(reduce merge2 maps))))
(defn neg? [n]
"Return true if n is < 0"
(_numeric-check n)
@ -254,11 +291,10 @@
(import numbers)
(instance? numbers.Number x))
(defn nth [coll index]
"Return nth item in collection or sequence, counting from 0"
(try
(next (drop index coll))
(catch [e StopIteration] (raise (IndexError index)))))
(defn nth [coll n &optional [default nil]]
"Return nth item in collection or sequence, counting from 0.
Return nil if out of bounds unless specified otherwise."
(next (drop n coll) default))
(defn odd? [n]
"Return true if n is an odd number"
@ -270,13 +306,6 @@
(_numeric_check n)
(> n 0))
(defn remove [pred coll]
"Return coll with elements removed that pass `pred`"
(let [[citer (iter coll)]]
(for* [val citer]
(if (not (pred val))
(yield val)))))
(defn rest [coll]
"Get all the elements of a coll, except the first."
(drop 1 coll))
@ -291,8 +320,8 @@
(nth coll 1))
(defn some [pred coll]
"Return true if (pred x) is logical true for any x in coll, else false"
(any (map pred coll)))
"Return the first logical true value of (pred x) for any x in coll, else nil"
(first (filter nil (map pred coll))))
(defn string [x]
"Cast x as current string implementation"
@ -327,10 +356,63 @@
(_numeric_check n)
(= n 0))
(def *exports* '[calling-module-name coll? cons cons? cycle dec distinct
disassemble drop drop-while empty? even? every? first filter
flatten float? gensym identity inc instance? integer
integer? integer-char? iterable? iterate iterator? keyword?
list* macroexpand macroexpand-1 map neg? nil? none? nth
numeric? odd? pos? range remove repeat repeatedly rest second
some string string? take take-nth take-while zero? zip zipwith])
(defn read [&optional [from-file sys.stdin]
[eof ""]]
"Read from input and returns a tokenized string.
Can take a given input buffer to read from"
(def buff "")
(while true
(def inn (str (.read from-file 1)))
(if (= inn eof)
(throw (EOFError "Reached end of file" )))
(setv buff (+ buff inn))
(try
(def parsed (first (tokenize buff)))
(except [e [LexException PrematureEndOfInput IndexError]])
(else (if parsed (break)))))
parsed)
(defun Botsbuildbots () (Botsbuildbots))
(defn zipwith [func &rest lists]
"Zip the contents of several lists and map a function to the result"
(do
(import functools)
(map (functools.partial (fn [f args] (apply f args)) func) (apply zip lists))))
(defn hyify [text]
"Convert text to match hy identifier"
(.replace (string text) "_" "-"))
(defn keyword [value]
"Create a keyword from the given value. Strings numbers and even objects
with the __name__ magic will work"
(if (and (string? value) (value.startswith *keyword-prefix*))
(hyify value)
(if (string? value)
(HyKeyword (+ ":" (hyify value)))
(try
(hyify (.__name__ value))
(catch [] (HyKeyword (+ ":" (string value))))))))
(defn name [value]
"Convert the given value to a string. Keyword special character will be stripped.
String will be used as is. Even objects with the __name__ magic will work"
(if (and (string? value) (value.startswith *keyword-prefix*))
(hyify (slice value 2))
(if (string? value)
(hyify value)
(try
(hyify (. value __name__))
(catch [] (string value))))))
(def *exports* '[Botsbuildbots
butlast calling-module-name coll? cons cons? cycle
dec distinct disassemble drop drop-last drop-while empty? even?
every? first filter filterfalse flatten float? gensym identity
inc input instance? integer integer? integer-char? interleave
interpose iterable? iterate iterator? keyword keyword? list*
macroexpand macroexpand-1 map merge-with name neg? nil? none?
nth numeric? odd? pos? range read remove repeat repeatedly
rest reduce second some string string? take take-nth
take-while zero? zip zip_longest zipwith])

93
hy/core/macros.hy
View File

@ -31,34 +31,6 @@
[hy._compat [PY33 PY34]])
(defmacro for [args &rest body]
"shorthand for nested for loops:
(for [x foo
y bar]
baz) ->
(for* [x foo]
(for* [y bar]
baz))"
(if (odd? (len args))
(macro-error args "`for' requires an even number of args."))
(if (empty? body)
(macro-error None "`for' requires a body to evaluate"))
(if (empty? args)
`(do ~@body)
(if (= (len args) 2)
; basecase, let's just slip right in.
`(for* [~@args] ~@body)
; otherwise, let's do some legit handling.
(let [[alist (slice args 0 nil 2)]
[ilist (slice args 1 nil 2)]]
`(do
(import itertools)
(for* [(, ~@alist) (itertools.product ~@ilist)] ~@body))))))
(defmacro with [args &rest body]
"shorthand for nested for* loops:
(with [[x foo] [y bar]] baz) ->
@ -116,6 +88,26 @@
root)
(defmacro for [args &rest body]
"shorthand for nested for loops:
(for [x foo
y bar]
baz) ->
(for* [x foo]
(for* [y bar]
baz))"
(cond
[(odd? (len args))
(macro-error args "`for' requires an even number of args.")]
[(empty? body)
(macro-error None "`for' requires a body to evaluate")]
[(empty? args) `(do ~@body)]
[(= (len args) 2) `(for* [~@args] ~@body)]
[true
(let [[alist (slice args 0 nil 2)]]
`(for* [(, ~@alist) (genexpr (, ~@alist) [~@args])] ~@body))]))
(defmacro -> [head &rest rest]
;; TODO: fix the docstring by someone who understands this
(setv ret head)
@ -127,6 +119,18 @@
ret)
(defmacro doto [form &rest expressions]
"Performs a sequence of potentially mutating actions
on an initial object, returning the resulting object"
(setv f (gensym))
(defn build-form [expression]
(if (isinstance expression HyExpression)
`(~(first expression) ~f ~@(rest expression))
`(~expression ~f)))
`(let [[~f ~form]]
~@(map build-form expressions)
~f))
(defmacro ->> [head &rest rest]
;; TODO: fix the docstring by someone who understands this
(setv ret head)
@ -149,6 +153,10 @@
"Like `if`, but anything that is not None/nil is considered true."
`(if (is-not ~test nil) ~@branches))
(defmacro-alias [lisp-if-not lif-not] [test &rest branches]
"Like `if-not`, but anything that is not None/nil is considered true."
`(if (is ~test nil) ~@branches))
(defmacro when [test &rest body]
"Execute `body` when `test` is true"
@ -165,11 +173,26 @@
~@body))
(defmacro defmacro/g! [name args &rest body]
(let [[syms (list (distinct (filter (fn [x] (.startswith x "g!")) (flatten body))))]]
(let [[syms (list (distinct (filter (fn [x] (and (hasattr x "startswith") (.startswith x "g!"))) (flatten body))))]]
`(defmacro ~name [~@args]
(let ~(HyList (map (fn [x] `[~x (gensym (slice '~x 2))]) syms))
~@body))))
(defmacro defmain [args &rest body]
"Write a function named \"main\" and do the if __main__ dance"
(let [[retval (gensym)]]
`(do
(defn main [~@args]
~@body)
(when (= --name-- "__main__")
(import sys)
(setv ~retval (apply main sys.argv))
(if (integer? ~retval)
(sys.exit ~retval))))))
(defmacro-alias [defn-alias defun-alias] [names lambda-list &rest body]
"define one function with several names"
(let [[main (first names)]
@ -179,3 +202,15 @@
(.append ret
`(setv ~name ~main)))
ret))
(defmacro Botsbuildbots []
"Build bots, repeatedly.^W^W^WPrint the AUTHORS, forever."
`(try
(do
(import [requests])
(let [[r (requests.get
"https://raw.githubusercontent.com/hylang/hy/master/AUTHORS")]]
(repeat r.text)))
(catch [e ImportError]
(repeat "Botsbuildbots requires `requests' to function."))))

64
hy/core/shadow.hy Normal file
View File

@ -0,0 +1,64 @@
;; Copyright (c) 2014 Paul Tagliamonte <paultag@debian.org>
;; Copyright (c) 2014 James King <james@agentultra.com>
;; Permission is hereby granted, free of charge, to any person obtaining a
;; copy of this software and associated documentation files (the "Software"),
;; to deal in the Software without restriction, including without limitation
;; the rights to use, copy, modify, merge, publish, distribute, sublicense,
;; and/or sell copies of the Software, and to permit persons to whom the
;; Software is furnished to do so, subject to the following conditions:
;; The above copyright notice and this permission notice shall be included in
;; all copies or substantial portions of the Software.
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
;; THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;; DEALINGS IN THE SOFTWARE.
;;;; Hy shadow functions
(import operator)
(defn + [&rest args]
"Shadow + operator for when we need to import / map it against something"
(let [[count (len args)]]
(if (zero? count)
(raise (TypeError "Need at least 1 argument to add/concatenate"))
(if (= count 1)
(get args 0)
(reduce operator.add args)))))
(defn - [&rest args]
"Shadow - operator for when we need to import / map it against something"
(let [[count (len args)]]
(if (= count 0)
(raise (TypeError "Need at least 1 argument to subtract"))
(if (= count 1)
(- (get args 0))
(reduce operator.sub args)))))
(defn * [&rest args]
"Shadow * operator for when we need to import / map it against something"
(if (= (len args) 0)
1 ; identity
(reduce operator.mul args)))
(defn / [&rest args]
"Shadow / operator for when we need to import / map it against something"
(let [[count (len args)]]
(if (= count 0)
(raise (TypeError "Need at least 1 argument to divide"))
(if (= count 1)
(operator.truediv 1 (get args 0))
(reduce operator.truediv args)))))
(setv *exports* ['+ '- '* '/])

2
hy/errors.py
View File

@ -28,7 +28,7 @@ import traceback
class HyError(Exception):
"""
Generic Hy error. All interal Exceptions will be subclassed from this
Generic Hy error. All internal Exceptions will be subclassed from this
Exception.
"""
pass

4
hy/lex/parser.py
View File

@ -30,7 +30,6 @@ from hy.models.expression import HyExpression
from hy.models.float import HyFloat
from hy.models.integer import HyInteger
from hy.models.keyword import HyKeyword
from hy.models.lambdalist import HyLambdaListKeyword
from hy.models.list import HyList
from hy.models.string import HyString
from hy.models.symbol import HySymbol
@ -271,9 +270,6 @@ def t_identifier(p):
if obj.startswith(":"):
return HyKeyword(obj)
if obj.startswith("&"):
return HyLambdaListKeyword(obj)
def mangle(p):
if p.startswith("*") and p.endswith("*") and p not in ("*", "**"):
p = p[1:-1].upper()

1
hy/macros.py
View File

@ -117,6 +117,7 @@ _wrappers = {
list: lambda l: HyList(_wrap_value(x) for x in l),
tuple: lambda t: HyList(_wrap_value(x) for x in t),
type(None): lambda foo: HySymbol("None"),
HyExpression: lambda e: HyExpression(_wrap_value(x) for x in e),
}
if sys.version_info[0] < 3: # do not add long on python3

2
hy/models/complex.py
View File

@ -23,7 +23,7 @@ from hy.models import HyObject
class HyComplex(HyObject, complex):
"""
Internal represntation of a Hy Complex. May raise a ValueError as if
Internal representation of a Hy Complex. May raise a ValueError as if
complex(foo) was called, given HyComplex(foo).
"""

2
hy/models/float.py
View File

@ -23,7 +23,7 @@ from hy.models import HyObject
class HyFloat(HyObject, float):
"""
Internal represntation of a Hy Float. May raise a ValueError as if
Internal representation of a Hy Float. May raise a ValueError as if
float(foo) was called, given HyFloat(foo).
"""

2
hy/models/integer.py
View File

@ -24,7 +24,7 @@ from hy._compat import long_type
class HyInteger(HyObject, long_type):
"""
Internal represntation of a Hy Integer. May raise a ValueError as if
Internal representation of a Hy Integer. May raise a ValueError as if
int(foo) was called, given HyInteger(foo). On python 2.x long will
be used instead
"""

7
hy/models/keyword.py
View File

@ -23,14 +23,17 @@ from hy.models import HyObject
from hy._compat import str_type
KEYWORD_PREFIX = "\uFDD0"
class HyKeyword(HyObject, str_type):
"""Generic Hy Keyword object. It's either a ``str`` or a ``unicode``,
depending on the Python version.
"""
def __new__(cls, value):
if not value.startswith("\uFDD0"):
value = "\uFDD0" + value
if not value.startswith(KEYWORD_PREFIX):
value = KEYWORD_PREFIX + value
obj = str_type.__new__(cls, value)
return obj

39
hy/models/lambdalist.py
View File

@ -1,39 +0,0 @@
# Copyright (c) 2013 James King <james@agentultra.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
from hy.models.string import HyString
class HyLambdaListKeyword(HyString):
"""
Hy LambdaListKeyword. Demarcates arguments in an argument list.
(defun my-fun (x &rest xs &optional (foo "default string")))
becomes:
def my_fun(x, *xs, foo="default string"):
pass
"""
_valid_types = ["&rest", "&optional", "&key", "&kwargs"]
def __init__(self, string):
self += string

2
hy/version.py
View File

@ -20,4 +20,4 @@
__appname__ = "hy"
__version__ = "0.10.0"
__version__ = "0.10.1"

5
requirements-dev.txt
View File

@ -1,11 +1,8 @@
-r requirements-travis.txt
# test tools
nose
tox
# code quality
flake8
coverage
# documentation
Pygments>=1.6
Sphinx

5
requirements-travis.txt Normal file
View File

@ -0,0 +1,5 @@
# for Botsbuildbots
requests
# code quality
flake8
coverage

66
scripts/reformat-changelog Executable file
View File

@ -0,0 +1,66 @@
#!/usr/bin/env hy
(import re)
(import pdb)
(import codecs)
(setv *maintainer-line*
" -- Alexander Artemenko <svetlyak.40wt@gmail.com> Thu, 30 Sep 2014 13:06:09 +0400")
(defun read-lines-from-file [filename]
(let [[f (codecs.open filename "r" "utf-8")]]
(fn [] (let [[line (.readline f) ]]
line))))
(defun get-version-number [line]
(let [[match (re.search r"Changes from.*(\d+\.\d+\.\d+)$" line)]]
(if match
(let [[version (.group match (int 1))]
[numbered (list (map int (.split version "."))) ]
[explicit-mapping {"0.9.12" "0.10.0"
"0.8.2" "0.9.0"}]]
(assoc numbered 2 (+ (get numbered 2) 1))
(.get explicit-mapping
version
(.join "." (map str numbered)))))))
(defun read-version-content [reader]
(setv line (reader))
(setv content [])
(while (and line (not (get-version-number line)))
(.append content (.strip line))
(setv line (reader)))
[content line])
(defun read-versions-from-file [filename]
(let [[reader (read-lines-from-file filename)]]
(read-versions-rec (reader)
reader)))
(defun read-versions-rec [line reader]
(if line
(let [[version (get-version-number line)]
[[content next-line] (read-version-content reader)]]
(+ [{"from" version
"content" content}]
(read-versions-rec next-line reader)))
[]))
(defun format-deb-version [version]
(setv result [(.format "hy ({}) unstable; urgency=low"
(get version "from"))])
(for [line (get version "content")]
(.append result (+ " " line)))
(.append result *maintainer-line*)
(.append result "")
(.join "\n" result))
(defmain [&rest args]
(let ((versions (read-versions-from-file "NEWS")))
(for [version versions]
(print (.encode (format-deb-version version) "utf-8")))))

7
tests/__init__.py
View File

@ -1,7 +1,6 @@
#
import hy # noqa
from hy._compat import PY3
from .native_tests.cons import * # noqa
from .native_tests.defclass import * # noqa
from .native_tests.mathematics import * # noqa
@ -13,6 +12,7 @@ from .native_tests.when import * # noqa
from .native_tests.with_decorator import * # noqa
from .native_tests.core import * # noqa
from .native_tests.reader_macros import * # noqa
from .native_tests.shadow import * # noqa
from .native_tests.with_test import * # noqa
from .native_tests.contrib.anaphoric import * # noqa
from .native_tests.contrib.loop import * # noqa
@ -20,3 +20,6 @@ from .native_tests.contrib.meth import * # noqa
from .native_tests.contrib.walk import * # noqa
from .native_tests.contrib.multi import * # noqa
from .native_tests.contrib.curry import * # noqa
if PY3:
from .native_tests.py3_only_tests import * # noqa

15
tests/compilers/test_ast.py
View File

@ -27,6 +27,7 @@ from hy.compiler import hy_compile
from hy.errors import HyCompileError, HyTypeError
from hy.lex.exceptions import LexException
from hy.lex import tokenize
from hy._compat import PY3
import ast
@ -111,23 +112,29 @@ def test_ast_good_do():
def test_ast_good_throw():
"Make sure AST can compile valid throw"
can_compile("(throw)")
can_compile("(throw 1)")
can_compile("(throw Exception)")
def test_ast_bad_throw():
"Make sure AST can't compile invalid throw"
cant_compile("(raise 1 2 3)")
cant_compile("(throw Exception Exception)")
def test_ast_good_raise():
"Make sure AST can compile valid raise"
can_compile("(raise)")
can_compile("(raise 1)")
can_compile("(raise Exception)")
can_compile("(raise e)")
if PY3:
def test_ast_raise_from():
can_compile("(raise Exception :from NameError)")
def test_ast_bad_raise():
"Make sure AST can't compile invalid raise"
cant_compile("(raise 1 2 3)")
cant_compile("(raise Exception Exception)")
def test_ast_good_try():

9
tests/lex/test_lex.py
View File

@ -21,7 +21,6 @@
from hy.models.expression import HyExpression
from hy.models.integer import HyInteger
from hy.models.lambdalist import HyLambdaListKeyword
from hy.models.float import HyFloat
from hy.models.complex import HyComplex
from hy.models.symbol import HySymbol
@ -85,14 +84,6 @@ def test_lex_expression_integer():
assert objs == [HyExpression([HySymbol("foo"), HyInteger(2)])]
def test_lex_lambda_list_keyword():
""" Make sure expressions can produce lambda list keywords """
objs = tokenize("(x &rest xs)")
assert objs == [HyExpression([HySymbol("x"),
HyLambdaListKeyword("&rest"),
HySymbol("xs")])]
def test_lex_symbols():
""" Make sure that symbols are valid expressions"""
objs = tokenize("foo ")

28
tests/macros/test_wrap_value.py Normal file
View File

@ -0,0 +1,28 @@
from hy._compat import long_type
from hy.models.integer import HyInteger
from hy.models.list import HyList
from hy.models.expression import HyExpression
from hy.macros import _wrap_value
def test_wrap_long_type():
""" Test conversion of integers."""
wrapped = _wrap_value(long_type(0))
assert type(wrapped) == HyInteger
def test_wrap_tuple():
""" Test conversion of tuples."""
wrapped = _wrap_value((HyInteger(0),))
assert type(wrapped) == HyList
assert type(wrapped[0]) == HyInteger
assert wrapped == HyList([HyInteger(0)])
def test_wrap_nested_expr():
""" Test conversion of HyExpressions with embedded non-HyObjects."""
wrapped = _wrap_value(HyExpression([long_type(0)]))
assert type(wrapped) == HyExpression
assert type(wrapped[0]) == HyInteger
assert wrapped == HyExpression([HyInteger(0)])

10
tests/native_tests/contrib/anaphoric.hy
View File

@ -54,7 +54,9 @@
(assert-equal (list (ap-map (* it 3) [1 2 3]))
[3 6 9])
(assert-equal (list (ap-map (* it 3) []))
[]))
[])
(assert-equal (let [[v 1] [f 1]] (list (ap-map (it v f) [(fn [a b] (+ a b))])))
[2]))
(defn test-ap-map-when []
"NATIVE: testing anaphoric map-when"
@ -85,12 +87,14 @@
(defn test-ap-first []
"NATIVE: testing anaphoric first"
(assert-equal (ap-first (> it 5) (range 10)) 6)
(assert-equal (ap-first (even? it) [1 2 3 4]) 2))
(assert-equal (ap-first (even? it) [1 2 3 4]) 2)
(assert-equal (ap-first (> it 10) (range 10)) None))
(defn test-ap-last []
"NATIVE: testing anaphoric last"
(assert-equal (ap-last (> it 5) (range 10)) 9)
(assert-equal (ap-last (even? it) [1 2 3 4]) 4))
(assert-equal (ap-last (even? it) [1 2 3 4]) 4)
(assert-equal (ap-last (> it 10) (range 10)) None))
(defn test-ap-reduce []
"NATIVE: testing anaphoric reduce"

115
tests/native_tests/core.hy
View File

@ -30,6 +30,9 @@
(defn assert-equal [x y]
(assert (= x y)))
(defn assert-nil [x]
(assert (is x nil)))
(defn test-coll? []
"NATIVE: testing coll?"
(assert-true (coll? [1 2 3]))
@ -38,6 +41,19 @@
(assert-false (coll? "abc"))
(assert-false (coll? 1)))
(defn test-butlast []
"NATIVE: testing butlast function"
(assert-equal (list (butlast (range 10)))
[0 1 2 3 4 5 6 7 8])
(assert-equal (list (butlast [1]))
[])
(assert-equal (list (butlast []))
[])
; with an infinite sequence
(import itertools)
(assert-equal (list (take 5 (butlast (itertools.count 10))))
[10 11 12 13 14]))
(defn test-cycle []
"NATIVE: testing cycle"
(assert-equal (list (cycle [])) [])
@ -57,6 +73,34 @@
(try (do (dec None) (assert False))
(catch [e [TypeError]] (assert (in "not a number" (str e))))))
(defn test-setv []
"NATIVE: testing setv mutation"
(setv x 1)
(setv y 1)
(assert-equal x y)
(setv x (setv y 12))
(assert-equal x 12)
(assert-equal y 12)
(setv x (setv y (fn [x] 9)))
(assert-equal (x y) 9)
(assert-equal (y x) 9)
(try (do (setv a.b 1) (assert False))
(catch [e [NameError]] (assert (in "name 'a' is not defined" (str e)))))
(try (do (setv b.a (fn [x] x)) (assert False))
(catch [e [NameError]] (assert (in "name 'b' is not defined" (str e)))))
(import itertools)
(setv foopermutations (fn [x] (itertools.permutations x)))
(setv p (set [(, 1 3 2) (, 3 2 1) (, 2 1 3) (, 3 1 2) (, 1 2 3) (, 2 3 1)]))
(assert-equal (set (itertools.permutations [1 2 3])) p)
(assert-equal (set (foopermutations [3 1 2])) p)
(setv permutations- itertools.permutations)
(setv itertools.permutations (fn [x] 9))
(assert-equal (itertools.permutations p) 9)
(assert-equal (foopermutations foopermutations) 9)
(setv itertools.permutations permutations-)
(assert-equal (set (itertools.permutations [2 1 3])) p)
(assert-equal (set (foopermutations [2 3 1])) p))
(defn test-distinct []
"NATIVE: testing the distinct function"
(setv res (list (distinct [ 1 2 3 4 3 5 2 ])))
@ -89,6 +133,19 @@
(setv res (list (take 5 (drop 2 (iterate inc 0)))))
(assert-equal res [2 3 4 5 6]))
(defn test-drop-last []
"NATIVE: testing drop-last function"
(assert-equal (list (drop-last 5 (range 10 20)))
[10 11 12 13 14])
(assert-equal (list (drop-last 0 (range 5)))
[0 1 2 3 4])
(assert-equal (list (drop-last 100 (range 100)))
[])
; with an infinite sequence
(import itertools)
(assert-equal (list (take 5 (drop-last 100 (itertools.count 10))))
[10 11 12 13 14]))
(defn test-drop-while []
"NATIVE: testing drop-while function"
(setv res (list (drop-while even? [2 4 7 8 9])))
@ -238,6 +295,33 @@
(assert-false (integer-char? "foo"))
(assert-false (integer-char? None)))
(defn test-interleave []
"NATIVE: testing the interleave function"
;; with more than 2 sequences
(assert-equal (list (take 9 (interleave (range 10)
(range 10 20)
(range 20 30))))
[0 10 20 1 11 21 2 12 22])
;; with sequences of different length
(assert-equal (list (interleave (range 1000000)
(range 0 -3 -1)))
[0 0 1 -1 2 -2])
;; with infinite sequences
(import itertools)
(assert-equal (list (take 10 (interleave (itertools.count)
(itertools.count 100))))
[0 100 1 101 2 102 3 103 4 104]))
(defn test-interpose []
"NATIVE: testing the interpose function"
;; with a list
(assert-equal (list (interpose "!" ["a" "b" "c"]))
["a" "!" "b" "!" "c"])
;; with an infinite sequence
(import itertools)
(assert-equal (list (take 7 (interpose -1 (itertools.count))))
[0 -1 1 -1 2 -1 3]))
(defn test-iterable []
"NATIVE: testing iterable? function"
;; should work for a string
@ -335,13 +419,17 @@
"NATIVE: testing the nth function"
(assert-equal 2 (nth [1 2 4 7] 1))
(assert-equal 7 (nth [1 2 4 7] 3))
(try (do (nth [1 2 4 7] 5) (assert False))
(catch [e [IndexError]] nil))
(assert-nil (nth [1 2 4 7] 5))
(assert-equal (nth [1 2 4 7] 5 "some default value")
"some default value") ; with default specified
(try (do (nth [1 2 4 7] -1) (assert False))
(catch [e [ValueError]] nil))
;; now for iterators
(assert-equal 2 (nth (iter [1 2 4 7]) 1))
(assert-equal 7 (nth (iter [1 2 4 7]) 3))
(assert-nil (nth (iter [1 2 4 7]) 5))
(assert-equal (nth (iter [1 2 4 7]) 5 "some default value")
"some default value") ; with default specified
(try (do (nth (iter [1 2 4 7]) -1) (assert False))
(catch [e [ValueError]] nil))
(assert-equal 5 (nth (take 3 (drop 2 [1 2 3 4 5 6])) 2)))
@ -412,9 +500,16 @@
(defn test-some []
"NATIVE: testing the some function"
(assert-true (some even? [2 4 6]))
(assert-false (some even? [1 3 5]))
(assert-true (some even? [1 3 6]))
(assert-false (some even? [])))
(assert-nil (some even? [1 3 5]))
(assert-true (some even? [1 2 3]))
(assert-nil (some even? []))
; 0, "" (empty string) and [] (empty list) are all logical false
(assert-nil (some identity [0 "" []]))
; non-empty string is logical true
(assert-equal (some identity [0 "this string is non-empty" []])
"this string is non-empty")
; nil if collection is empty
(assert-nil (some even? [])))
(defn test-string? []
"NATIVE: testing string?"
@ -482,6 +577,16 @@
(setv res (zipwith operator.sub [3 7 9] [1 2 4]))
(assert-equal (list res) [2 5 5]))
(defn test-doto []
"NATIVE: testing doto macro"
(setv collection [])
(doto collection (.append 1) (.append 2) (.append 3))
(assert-equal collection [1 2 3])
(setv res (doto (set) (.add 2) (.add 1)))
(assert-equal res (set [1 2]))
(setv res (doto [] (.append 1) (.append 2) .reverse))
(assert-equal res [2 1]))
(defn test-is-keyword []
"NATIVE: testing the keyword? function"
(assert (keyword? ':bar))

10
tests/native_tests/defclass.hy
View File

@ -20,16 +20,16 @@
(assert (not (isinstance (A) D))))
(defn test-defclass-slots []
"NATIVE: test defclass slots"
(defn test-defclass-attrs []
"NATIVE: test defclass attributes"
(defclass A []
[[x 42]])
(assert (= A.x 42))
(assert (= (getattr (A) "x") 42)))
(defn test-defclass-slots-fn []
"NATIVE: test defclass slots with fn"
(defn test-defclass-attrs-fn []
"NATIVE: test defclass attributes with fn"
(defclass B []
[[x 42]
[y (fn [self value]
@ -52,7 +52,7 @@
(defn test-defclass-no-fn-leak []
"NATIVE: test defclass slots with fn"
"NATIVE: test defclass attributes with fn"
(defclass A []
[[x (fn [] 1)]])
(try

154
tests/native_tests/language.hy
View File

@ -1,8 +1,10 @@
(import [tests.resources [kwtest function-with-a-dash]]
[os.path [exists isdir isfile]]
[sys :as systest])
[sys :as systest]
[operator [or_]])
(import sys)
(import [hy._compat [PY33 PY34]])
(defn test-sys-argv []
"NATIVE: test sys.argv"
@ -27,9 +29,31 @@
(setv (get foo 0) 12)
(assert (= (get foo 0) 12)))
(defn test-setv-builtin []
"NATIVE: test that setv doesn't work on builtins"
(try (eval '(setv False 1))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv True 0))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv None 1))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv false 1))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv true 0))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv nil 1))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(setv null 1))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(defn defclass [] (print "hello")))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(defn get [] (print "hello")))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e)))))
(try (eval '(defn lambda [] (print "hello")))
(catch [e [TypeError]] (assert (in "Can't assign to a builtin" (str e))))))
(defn test-for-loop []
"NATIVE: test for loops?"
"NATIVE: test for loops"
(setv count 0)
(for [x [1 2 3 4 5]]
(setv count (+ count x)))
@ -38,7 +62,11 @@
(for [x [1 2 3 4 5]
y [1 2 3 4 5]]
(setv count (+ count x y)))
(assert (= count 150)))
(assert (= count 150))
(assert (= (list ((fn [] (for [x [[1] [2 3]] y x] (yield y)))))
(list-comp y [x [[1] [2 3]] y x])))
(assert (= (list ((fn [] (for [x [[1] [2 3]] y x z (range 5)] (yield z)))))
(list-comp z [x [[1] [2 3]] y x z (range 5)]))))
(defn test-nasty-for-nesting []
@ -444,10 +472,35 @@
(for [y (gen)] (setv ret (+ ret y)))
(assert (= ret 10)))
(defn test-yield-with-return []
"NATIVE: test yield with return"
(defn gen [] (yield 3) "goodbye")
(if PY33
(do (setv gg (gen))
(assert (= 3 (next gg)))
(try (next gg)
(except [e StopIteration] (assert (hasattr e "value"))
(assert (= (getattr e "value") "goodbye")))))
(do (setv gg (gen))
(assert (= 3 (next gg)))
(try (next gg)
(except [e StopIteration] (assert (not (hasattr e "value"))))))))
(defn test-yield-in-try []
"NATIVE: test yield in try"
(defn gen []
(let [[x 1]]
(try (yield x)
(finally (print x)))))
(setv output (list (gen)))
(assert (= [1] output)))
(defn test-first []
"NATIVE: test firsty things"
(assert (= (first [1 2 3 4 5]) 1))
(assert (is (first []) nil))
(assert (= (car [1 2 3 4 5]) 1)))
@ -958,6 +1011,24 @@
(assert (= (macroexpand-1 '(-> (a b) (-> (c d) (e f))))
'(-> (a b) (c d) (e f)))))
(defn test-merge-with []
"NATIVE: test merge-with"
(assert (= (merge-with + {} {}) nil))
(assert (= (merge-with + {"a" 10 "b" 20} {}) {"a" 10 "b" 20}))
(assert (= (merge-with + {} {"a" 10 "b" 20}) {"a" 10 "b" 20}))
(assert (= (merge-with + {"a" 10 "b" 20} {"a" 1 "c" 30})
{"a" 11 "b" 20 "c" 30}))
(assert (= (merge-with +
{:a 1 :b 2}
{:a 9 :b 98 :c 0}
{:a 10 :b 100 :c 10}
{:a 5}
{:c 5 :d 42})
{:d 42 :c 15 :a 25 :b 200}))
(assert (= (merge-with or_
{"a" (set [1 2 3]) "b" (set [4 5 6])}
{"a" (set [2 3 7 8]) "c" (set [1 2 3])})
{"a" (set [1 2 3 7 8]) "c" (set [1 2 3]) "b" (set [4 5 6])})))
(defn test-calling-module-name []
"NATIVE: Test the calling-module-name function"
@ -967,22 +1038,10 @@
(defn test-disassemble []
"NATIVE: Test the disassemble function"
(import sys)
(if-python2
(import [io [BytesIO :as StringIO]])
(import [io [StringIO]]))
(setv prev-stdout sys.stdout)
(setv sys.stdout (StringIO))
(disassemble '(do (leaky) (leaky) (macros)))
(setv stdout (.getvalue sys.stdout))
(setv sys.stdout prev-stdout)
(assert (in "leaky" stdout))
(assert (in "macros" stdout))
(setv sys.stdout (StringIO))
(disassemble '(do (leaky) (leaky) (macros)) true)
(setv stdout (.getvalue sys.stdout))
(setv sys.stdout prev-stdout)
(assert (= stdout "leaky()\nleaky()\nmacros()\n")))
(assert (= (disassemble '(do (leaky) (leaky) (macros)))
"Module(\n body=[\n Expr(value=Call(func=Name(id='leaky'), args=[], keywords=[], starargs=None, kwargs=None)),\n Expr(value=Call(func=Name(id='leaky'), args=[], keywords=[], starargs=None, kwargs=None)),\n Expr(value=Call(func=Name(id='macros'), args=[], keywords=[], starargs=None, kwargs=None))])"))
(assert (= (disassemble '(do (leaky) (leaky) (macros)) true)
"leaky()\nleaky()\nmacros()")))
(defn test-attribute-access []
@ -1008,3 +1067,60 @@
"NATIVE: test keyword quoting magic"
(assert (= :foo "\ufdd0:foo"))
(assert (= `:foo "\ufdd0:foo")))
(defn test-only-parse-lambda-list-in-defn []
"NATIVE: test lambda lists are only parsed in defn"
(try
(foo [&rest spam] 1)
(catch [NameError] True)
(else (raise AssertionError))))
(defn test-read []
"NATIVE: test that read takes something for stdin and reads"
(if-python2
(import [StringIO [StringIO]])
(import [io [StringIO]]))
(import [hy.models.expression [HyExpression]])
(def stdin-buffer (StringIO "(+ 2 2)\n(- 2 2)"))
(assert (= (eval (read stdin-buffer)) 4))
(assert (isinstance (read stdin-buffer) HyExpression))
"Multiline test"
(def stdin-buffer (StringIO "(\n+\n41\n1\n)\n(-\n2\n1\n)"))
(assert (= (eval (read stdin-buffer)) 42))
(assert (= (eval (read stdin-buffer)) 1))
"EOF test"
(def stdin-buffer (StringIO "(+ 2 2)"))
(read stdin-buffer)
(try
(read stdin-buffer)
(catch [e Exception]
(assert (isinstance e EOFError)))))
(defn test-keyword-creation []
"NATIVE: Test keyword creation"
(assert (= (keyword "foo") :foo))
(assert (= (keyword "foo_bar") :foo-bar))
(assert (= (keyword `foo) :foo))
(assert (= (keyword `foo-bar) :foo-bar))
(assert (= (keyword 'foo) :foo))
(assert (= (keyword 'foo-bar) :foo-bar))
(assert (= (keyword 1) :1))
(assert (= (keyword 1.0) :1.0))
(assert (= (keyword :foo_bar) :foo-bar)))
(defn test-name-conversion []
"NATIVE: Test name conversion"
(assert (= (name "foo") "foo"))
(assert (= (name "foo_bar") "foo-bar"))
(assert (= (name `foo) "foo"))
(assert (= (name `foo_bar) "foo-bar"))
(assert (= (name 'foo) "foo"))
(assert (= (name 'foo_bar) "foo-bar"))
(assert (= (name 1) "1"))
(assert (= (name 1.0) "1.0"))
(assert (= (name :foo) "foo"))
(assert (= (name :foo_bar) "foo-bar"))
(assert (= (name test-name-conversion) "test-name-conversion")))

46
tests/native_tests/native_macros.hy
View File

@ -1,6 +1,3 @@
(import [hy._compat [PY33]])
(import [hy.errors [HyCompileError]])
(defmacro rev [&rest body]
"Execute the `body` statements in reverse"
(quasiquote (do (unquote-splice (list (reversed body))))))
@ -100,21 +97,6 @@
(assert initialized)
(assert (test-initialized))
(defn test-yield-from []
"NATIVE: testing yield from"
(try
(eval
'(do (defn yield-from-test []
(for* [i (range 3)]
(yield i))
(yield-from [1 2 3]))
(assert (= (list (yield-from-test)) [0 1 2 1 2 3]))))
(catch [e HyCompileError]
;; Yup, this should happen on non-Python3.3 thingies
(assert (not PY33)))
(else (assert PY33))))
(defn test-if-python2 []
(import sys)
(assert (= (get sys.version_info 0)
@ -188,7 +170,12 @@
(setv s2 (to_source _ast2))
(assert (in ":res_" s1))
(assert (in ":res_" s2))
(assert (not (= s1 s2))))
(assert (not (= s1 s2)))
;; defmacro/g! didn't like numbers initially because they
;; don't have a startswith method and blew up during expansion
(setv macro2 "(defmacro/g! two-point-zero [] `(+ (float 1) 1.0))")
(assert (import_buffer_to_ast macro2 "foo")))
(defn test-if-not []
@ -219,6 +206,24 @@
(assert (= (lif nil "true" "false") "false"))
(assert (= (lif 0 "true" "false") "true")))
(defn test-lisp-if-not []
"test that lisp-if-not works as expected"
; nil is false
(assert (= (lisp-if-not None "false" "true") "false"))
(assert (= (lisp-if-not nil "false" "true") "false"))
; But everything else is True! Even falsey things.
(assert (= (lisp-if-not True "false" "true") "true"))
(assert (= (lisp-if-not False "false" "true") "true"))
(assert (= (lisp-if-not 0 "false" "true") "true"))
(assert (= (lisp-if-not "some-string" "false" "true") "true"))
(assert (= (lisp-if-not "" "false" "true") "true"))
(assert (= (lisp-if-not (+ 1 2 3) "false" "true") "true"))
; Just to be sure, test the alias lif-not
(assert (= (lif-not nil "false" "true") "false"))
(assert (= (lif-not 0 "false" "true") "true")))
(defn test-defn-alias []
(defn-alias [tda-main tda-a1 tda-a2] [] :bazinga)
@ -227,3 +232,6 @@
(assert (= (tda-a1) :bazinga))
(assert (= (tda-a2) :bazinga))
(assert (= tda-main tda-a1 tda-a2)))
(defn test-botsbuildbots []
(assert (> (len (first (Botsbuildbots))) 50)))

27
tests/native_tests/py3_only_tests.hy Normal file
View File

@ -0,0 +1,27 @@
;; Tests where the emited code relies on Python 3.
;; Conditionally included in nosetests runs.
(import [hy._compat [PY33]])
(import [hy.errors [HyCompileError]])
(defn test-yield-from []
"NATIVE: testing yield from"
(try
(eval
'(do (defn yield-from-test []
(for* [i (range 3)]
(yield i))
(yield-from [1 2 3]))
(assert (= (list (yield-from-test)) [0 1 2 1 2 3]))))
(catch [e HyCompileError]
;; Yield-from is supported in py3.3+ only
(assert (not PY33)))
(else (assert PY33))))
(defn test-exception-cause []
(try (raise ValueError :from NameError)
(except [e [ValueError]]
(assert (= (type (. e __cause__)) NameError)))))

6
tests/native_tests/quote.hy
View File

@ -77,12 +77,6 @@
(assert (= q qq)))
(defn test-quote-lambdalistkeyword []
"NATIVE: test quoting lambda list keywords"
(setv opt (quote &optional))
(assert (isinstance opt hy.HyLambdaListKeyword))
(assert (= (str opt) "&optional")))
(defmacro doodle [&rest body]
`(do ~@body))

52
tests/native_tests/shadow.hy Normal file
View File

@ -0,0 +1,52 @@
(defn test-shadow-addition []
"NATIVE: test shadow addition"
(let [[x +]]
(assert (try
(x)
(catch [TypeError] True)
(else (throw AssertionError))))
(assert (= (x 1 2 3 4) 10))
(assert (= (x 1 2 3 4 5) 15))
; with strings
(assert (= (x "a")
"a"))
(assert (= (x "a" "b" "c")
"abc"))
; with lists
(assert (= (x ["a"])
["a"]))
(assert (= (x ["a"] ["b"] ["c"])
["a" "b" "c"]))))
(defn test-shadow-subtraction []
"NATIVE: test shadow subtraction"
(let [[x -]]
(assert (try
(x)
(catch [TypeError] True)
(else (throw AssertionError))))
(assert (= (x 1) -1))
(assert (= (x 2 1) 1))
(assert (= (x 2 1 1) 0))))
(defn test-shadow-multiplication []
"NATIVE: test shadow multiplication"
(let [[x *]]
(assert (= (x) 1))
(assert (= (x 3) 3))
(assert (= (x 3 3) 9))))
(defn test-shadow-division []
"NATIVE: test shadow division"
(let [[x /]]
(assert (try
(x)
(catch [TypeError] True)
(else (throw AssertionError))))
(assert (= (x 1) 1))
(assert (= (x 8 2) 4))
(assert (= (x 8 2 2) 2))
(assert (= (x 8 2 2 2) 1))))

12
tests/native_tests/with_decorator.hy
View File

@ -7,6 +7,16 @@
(* 2 2)))
(defn bardec [cls]
(setv cls.my_attr 123)
cls)
(with-decorator bardec
(defclass cls []
[[my_attr 456]]))
(defn test-decorators []
"NATIVE: test decorators."
(assert (= (tfunction) 2)))
(assert (= (tfunction) 2))
(assert (= cls.my_attr 123)))

5
tests/resources/bin/main.hy Normal file
View File

@ -0,0 +1,5 @@
(defmain [&rest args]
(print args)
(print "Hello World")
(if (in "exit1" args)
1))

4
tests/resources/bin/nomain.hy Normal file
View File

@ -0,0 +1,4 @@
(print "This Should Still Works")
(defn main []
(print "This Should Not Work"))

45
tests/test_bin.py
View File

@ -23,10 +23,14 @@
# DEALINGS IN THE SOFTWARE.
import os
import subprocess
from hy._compat import PY3
hy_dir = os.environ.get('HY_DIR', '')
def run_cmd(cmd, stdin_data=None):
p = subprocess.Popen(cmd,
p = subprocess.Popen(os.path.join(hy_dir, cmd),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
@ -128,12 +132,15 @@ def test_hy2py():
for dirpath, dirnames, filenames in os.walk("tests/native_tests"):
for f in filenames:
if f.endswith(".hy"):
i += 1
ret = run_cmd("hy2py -s -a "
+ os.path.join(dirpath, f))
assert ret[0] == 0, f
assert len(ret[1]) > 1, f
assert len(ret[2]) == 0, f
if f == "py3_only_tests.hy" and not PY3:
continue
else:
i += 1
ret = run_cmd("hy2py -s -a "
+ os.path.join(dirpath, f))
assert ret[0] == 0, f
assert len(ret[1]) > 1, f
assert len(ret[2]) == 0, f
assert i
@ -142,3 +149,27 @@ def test_bin_hy_builtins():
assert str(exit) == "Use (exit) or Ctrl-D (i.e. EOF) to exit"
assert str(quit) == "Use (quit) or Ctrl-D (i.e. EOF) to exit"
def test_bin_hy_main():
ret = run_cmd("hy tests/resources/bin/main.hy")
assert ret[0] == 0
assert "Hello World" in ret[1]
def test_bin_hy_main_args():
ret = run_cmd("hy tests/resources/bin/main.hy test 123")
assert ret[0] == 0
assert "test" in ret[1]
assert "123" in ret[1]
def test_bin_hy_main_exitvalue():
ret = run_cmd("hy tests/resources/bin/main.hy exit1")
assert ret[0] == 1
def test_bin_hy_no_main():
ret = run_cmd("hy tests/resources/bin/nomain.hy")
assert ret[0] == 0
assert "This Should Still Work" in ret[1]