internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: hylang/hy

Issue:
Hy Repl's behaviour on multiline strings
Hy Repl throws a `LexException` when attempting to write a multiline docstring. 

```
 => (defn a []
...   "This is a dummy fn that really does
LexException: Could not identify the next token at line -1, column -1
```



Discussion:
I believe there is/was a bug regarding multiline comments in the REPL, but not sure about the status on that. The syntax however is `""" Hello """`, not single doublequotes.

The syntax is `"foo
bar"`, not the other thing.

@Foxboron: It was issue #253. I guess either this one or the other should be marked as duplicate and closed.


Resolving patch:
diff --git a/hy/lex/lexer.py b/hy/lex/lexer.py
--- a/hy/lex/lexer.py
+++ b/hy/lex/lexer.py
@@ -42,8 +42,9 @@
 lg.add('HASHBANG', r'#!.*[^\r\n]')
 lg.add('HASHREADER', r'#.')
 
-
-lg.add('STRING', r'''(?x)
+# A regexp which matches incomplete strings, used to support
+# multi-line strings in the interpreter
+partial_string = r'''(?x)
     (?:u|r|ur|ru)? # prefix
     "  # start string
     (?:
@@ -53,9 +54,10 @@
        | \\u[0-9a-fA-F]{4}  # or unicode escape
        | \\U[0-9a-fA-F]{8}  # or long unicode escape
     )* # one or more times
-    "  # end string
-''')
+'''
 
+lg.add('STRING', r'%s"' % partial_string)
+lg.add('PARTIAL_STRING', partial_string)
 
 lg.add('IDENTIFIER', r'[^()\[\]{}\'"\s;]+')
 
diff --git a/hy/lex/parser.py b/hy/lex/parser.py
--- a/hy/lex/parser.py
+++ b/hy/lex/parser.py
@@ -236,6 +236,12 @@ def t_string(p):
     return uni_hystring(s)
 
 
+@pg.production("string : PARTIAL_STRING")
+def t_partial_string(p):
+    # Any unterminated string requires more input
+    raise PrematureEndOfInput("Premature end of input")
+
+
 @pg.production("identifier : IDENTIFIER")
 @set_boundaries
 def t_identifier(p):


Test patch:
diff --git a/tests/lex/test_lex.py b/tests/lex/test_lex.py
--- a/tests/lex/test_lex.py
+++ b/tests/lex/test_lex.py
@@ -49,6 +49,11 @@ def test_lex_exception():
         assert True is False
     except PrematureEndOfInput:
         pass
+    try:
+        tokenize("(foo \"bar")
+        assert True is False
+    except PrematureEndOfInput:
+        pass
 
 
 def test_unbalanced_exception():
@@ -73,7 +78,7 @@ def test_lex_expression_symbols():
 
 
 def test_lex_expression_strings():
-    """ Test that expressions can produce symbols """
+    """ Test that expressions can produce strings """
     objs = tokenize("(foo \"bar\")")
     assert objs == [HyExpression([HySymbol("foo"), HyString("bar")])]
Repository: hylang/hy

Issue:
with-decorator clobbers previous decorators
When applying decorators to an already decorated function, hy clobbers the previous decorators.
so

```
(defn test_decorator_clobbing []
  (do
    (defn dec1 [f] (defn k [] (+ (f) 1)))
    (defn dec2 [f] (defn k [] (+ (f) 2)))
    (with-decorator dec1
      (with-decorator dec2
        (defn f [] 1)))
    (assert (= (f) 4))))
```

fails.



Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1295,7 +1295,7 @@ def compile_decorate_expression(self, expr):
                                 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
+        fn.stmts[-1].decorator_list = decorators + fn.stmts[-1].decorator_list
         return ret + fn
 
     @builds("with*")


Test patch:
diff --git a/tests/native_tests/with_decorator.hy b/tests/native_tests/with_decorator.hy
--- a/tests/native_tests/with_decorator.hy
+++ b/tests/native_tests/with_decorator.hy
@@ -15,6 +15,15 @@
   (defclass cls []
     [[my_attr 456]]))
 
+(defn test-decorator-clobbing []
+  "NATIVE: Tests whether nested decorators work"
+  (do
+    (defn dec1 [f] (defn k [] (+ (f) 1)))
+    (defn dec2 [f] (defn k [] (+ (f) 2)))
+    (with-decorator dec1
+      (with-decorator dec2
+        (defn f [] 1)))
+    (assert (= (f) 4))))
 
 (defn test-decorators []
   "NATIVE: test decorators."
Repository: hylang/hy

Issue:
Process correctly IOError raised from hy script
We getting such traceback when exception raised in the script inherits `IOError`

```
Traceback (most recent call last):
  File "~/.virtualenvs/demo/bin/hy", line 9, in <module>
    load_entry_point('hy==0.9.12', 'console_scripts', 'hy')()
  File "~/.virtualenvs/demo/lib/python2.7/site-packages/hy/cmdline.py", line 295, in hy_main
    sys.exit(cmdline_handler("hy", sys.argv))
  File "~/.virtualenvs/demo/lib/python2.7/site-packages/hy/cmdline.py", line 286, in cmdline_handler
    (x.filename, x.errno, x.strerror))
TypeError: %d format: a number is required, not NoneType
```

In my case I am using `requests` library that raises `requests.exceptions.ConnectionError` 



Discussion:
Hurm, yeah, this looks annoying. Thanks, @signalpillar !


Resolving patch:
diff --git a/hy/cmdline.py b/hy/cmdline.py
--- a/hy/cmdline.py
+++ b/hy/cmdline.py
@@ -43,6 +43,8 @@
 from hy.completer import completion
 from hy.completer import Completer
 
+from hy.errors import HyIOError
+
 from hy.macros import macro, require
 from hy.models.expression import HyExpression
 from hy.models.string import HyString
@@ -324,10 +326,10 @@ def cmdline_handler(scriptname, argv):
             # User did "hy <filename>"
             try:
                 return run_file(options.args[0])
-            except IOError as x:
+            except HyIOError as e:
                 sys.stderr.write("hy: Can't open file '%s': [Errno %d] %s\n" %
-                                 (x.filename, x.errno, x.strerror))
-                sys.exit(x.errno)
+                                 (e.filename, e.errno, e.strerror))
+                sys.exit(e.errno)
 
     # User did NOTHING!
     return run_repl(spy=options.spy)
diff --git a/hy/errors.py b/hy/errors.py
--- a/hy/errors.py
+++ b/hy/errors.py
@@ -111,3 +111,11 @@ def __str__(self):
 
 class HyMacroExpansionError(HyTypeError):
     pass
+
+
+class HyIOError(HyError, IOError):
+    """
+    Trivial subclass of IOError and HyError, to distinguish between
+    IOErrors thrown by Hy itself as opposed to Hy programs.
+    """
+    pass
diff --git a/hy/importer.py b/hy/importer.py
--- a/hy/importer.py
+++ b/hy/importer.py
@@ -22,6 +22,7 @@
 from hy.compiler import hy_compile, HyTypeError
 from hy.models import HyObject
 from hy.lex import tokenize, LexException
+from hy.errors import HyIOError
 
 from io import open
 import marshal
@@ -49,8 +50,11 @@ def import_buffer_to_hst(buf):
 
 def import_file_to_hst(fpath):
     """Import content from fpath and return an Hy AST."""
-    with open(fpath, 'r', encoding='utf-8') as f:
-        return import_buffer_to_hst(f.read())
+    try:
+        with open(fpath, 'r', encoding='utf-8') as f:
+            return import_buffer_to_hst(f.read())
+    except IOError as e:
+        raise HyIOError(e.errno, e.strerror, e.filename)
 
 
 def import_buffer_to_ast(buf, module_name):


Test patch:
Repository: hylang/hy

Issue:
Exclamation mark ! is not mangled
I noticed that https://github.com/hylang/hyway/blob/master/conway.hy uses "!" in `set!` and `get!`, but Hy doesn't mangle "!" into something else.  The variable is added to the module as-is.  That means it'll be hard to reach it from normal Python code.  Also, hy2py on Hy code with `set!` returns invalid syntax: `def set!(`.



Discussion:
```
Also, hy2py on Hy code with set! returns invalid syntax: def set!(.
```

The first is actually a problem, but imma just explain this part.
The AST dosnt care what we give it. It can take anything we'd like it to take, and it accepts it. hy2py dosnt return valid Python code, this is very apparent when you start using gensyms and have `:G_123 = True` which obviously isnt valid Python.
You have to seperate the two things, Python's AST dosn't follow the grammar of Python. Python puts its own restrictions on what it accepts, like `!`. In return, Hy can be more loose and accept unicode or bangs and question marks without any problem at all, except for the problem mentioned in this issue.

My opinion here is that this is not a bug. There are symbols that Python can't handle, but Hy can, and symbols that end with a bang are such. There's also `^`, and a couple of others that do not get mangled.

On the other hand, the `foo!` syntax is reasonably common, so... how about mangling that to `foo_bang` ?


Resolving patch:
diff --git a/hy/lex/parser.py b/hy/lex/parser.py
--- a/hy/lex/parser.py
+++ b/hy/lex/parser.py
@@ -308,6 +308,9 @@ def mangle(p):
         if p.endswith("?") and p != "?":
             p = "is_%s" % (p[:-1])
 
+        if p.endswith("!") and p != "!":
+            p = "%s_bang" % (p[:-1])
+
         return p
 
     obj = ".".join([mangle(part) for part in obj.split(".")])


Test patch:
diff --git a/tests/lex/test_lex.py b/tests/lex/test_lex.py
--- a/tests/lex/test_lex.py
+++ b/tests/lex/test_lex.py
@@ -326,6 +326,24 @@ def test_lex_mangling_qmark():
     assert entry == [HySymbol(".is_foo.bar.is_baz")]
 
 
+def test_lex_mangling_bang():
+    """Ensure that identifiers ending with a bang get mangled ok"""
+    entry = tokenize("foo!")
+    assert entry == [HySymbol("foo_bang")]
+    entry = tokenize("!")
+    assert entry == [HySymbol("!")]
+    entry = tokenize("im!foo")
+    assert entry == [HySymbol("im!foo")]
+    entry = tokenize(".foo!")
+    assert entry == [HySymbol(".foo_bang")]
+    entry = tokenize("foo.bar!")
+    assert entry == [HySymbol("foo.bar_bang")]
+    entry = tokenize("foo!.bar")
+    assert entry == [HySymbol("foo_bang.bar")]
+    entry = tokenize(".foo!.bar.baz!")
+    assert entry == [HySymbol(".foo_bang.bar.baz_bang")]
+
+
 def test_simple_cons():
     """Check that cons gets tokenized correctly"""
     entry = tokenize("(a . b)")[0]
Repository: hylang/hy

Issue:
`(genexpr [x [1 2 3]] x)` throws a segfault on Hy 0.10.0 with Python 2.7.4
Segfaults on OS X 10.9.2 and Ubuntu 13.04 (GNU/Linux 3.8.0-35-generic x86_64)

I need to recompile python with gdb support, but here's the stacktrace I was able to glean (sorry I couldn't be more help):

```
#0  0x0000000000454ec3 in ?? ()
#1  0x00000000004c031f in ?? ()
#2  0x0000000000472392 in ?? ()
#3  0x00000000004e7ab9 in PySymtable_Build ()
#4  0x00000000004e7bb1 in PyAST_Compile ()
#5  0x00000000004f6318 in ?? ()
#6  0x000000000047b96a in PyEval_EvalFrameEx ()
#7  0x000000000047c11f in PyEval_EvalFrameEx ()
#8  0x00000000004e048a in PyEval_EvalCodeEx ()
#9  0x000000000047bddd in PyEval_EvalFrameEx ()
#10 0x000000000047c11f in PyEval_EvalFrameEx ()
#11 0x00000000004e048a in PyEval_EvalCodeEx ()
#12 0x000000000047bddd in PyEval_EvalFrameEx ()
#13 0x00000000004e048a in PyEval_EvalCodeEx ()
#14 0x000000000047bddd in PyEval_EvalFrameEx ()
#15 0x000000000047c11f in PyEval_EvalFrameEx ()
#16 0x000000000047c11f in PyEval_EvalFrameEx ()
#17 0x00000000004e048a in PyEval_EvalCodeEx ()
#18 0x000000000053ff12 in PyEval_EvalCode ()
#19 0x000000000054038b in ?? ()
#20 0x0000000000465756 in PyRun_InteractiveOneFlags ()
#21 0x0000000000465849 in PyRun_InteractiveLoopFlags ()
#22 0x0000000000465ed3 in PyRun_AnyFileExFlags ()
#23 0x0000000000466b99 in Py_Main ()
#24 0x00007ffff6ef2ea5 in __libc_start_main ()
   from /lib/x86_64-linux-gnu/libc.so.6
#25 0x00000000004e1115 in _start ()
```



Discussion:
Oookay, so the following causes Python 2.7 to blow up horribly:

``` hy
(genexpr x [])
(genexpr [x [1 2 3]] x)
```

They all fail because the `ast.ListComp` generated by them crashes python. The python syntax does not allow either of these to happen.

I think we can guard against both of these reasonably well. I'll see what I can do.


Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1473,9 +1473,16 @@ def compile_list_comprehension(self, expr):
         # (list-comp expr (target iter) cond?)
         expr.pop(0)
         expression = expr.pop(0)
+        gen_gen = expr[0]
+
+        if not isinstance(gen_gen, HyList):
+            raise HyTypeError(gen_gen, "Generator expression must be a list.")
 
         gen_res, gen = self._compile_generator_iterables(expr)
 
+        if len(gen) == 0:
+            raise HyTypeError(gen_gen, "Generator expression cannot be empty.")
+
         compiled_expression = self.compile(expression)
         ret = compiled_expression + gen_res
         ret += ast.ListComp(


Test patch:
diff --git a/tests/compilers/test_ast.py b/tests/compilers/test_ast.py
--- a/tests/compilers/test_ast.py
+++ b/tests/compilers/test_ast.py
@@ -519,3 +519,11 @@ def test_attribute_access():
 def test_cons_correct():
     """Ensure cons gets compiled correctly"""
     can_compile("(cons a b)")
+
+
+def test_invalid_list_comprehension():
+    """Ensure that invalid list comprehensions do not break the compiler"""
+    cant_compile("(genexpr x [])")
+    cant_compile("(genexpr [x [1 2 3 4]] x)")
+    cant_compile("(list-comp None [])")
+    cant_compile("(list-comp [x [1 2 3]] x)")
Repository: hylang/hy

Issue:
Allow setv to take zero arguments
Common Lisp's `setf` doesn't crach on zero args:

``` Lisp
* (setf)

NIL
```

Clojure's `let` bindings can be empty:

``` Clojure
user=> (let [])
nil
```

One might ask, what possible use is an empty binding construct? Well, if you're defining variadic macros, it's easier to `(setv ~@pairs)` than to `(if pairs (setv ~@pairs))`. It's one less special case to deal with.



Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1977,10 +1977,15 @@ def compile_expression(self, expression):
 
     @builds("def")
     @builds("setv")
-    @checkargs(min=2)
     def compile_def_expression(self, expression):
-        expression.pop(0)
-        if len(expression) == 2:
+        root = expression.pop(0)
+        if not expression:
+            result = Result()
+            result += ast.Name(id='None', ctx=ast.Load(),
+                               lineno=root.start_line,
+                               col_offset=root.start_column)
+            return result
+        elif len(expression) == 2:
             return self._compile_assign(expression[0], expression[1],
                                         expression.start_line,
                                         expression.start_column)


Test patch:
diff --git a/tests/native_tests/language.hy b/tests/native_tests/language.hy
--- a/tests/native_tests/language.hy
+++ b/tests/native_tests/language.hy
@@ -34,6 +34,11 @@
   (assert (= #{} (set))))
 
 
+(defn test-setv-empty []
+  "NATIVE: test setv works with no arguments"
+  (assert (is (setv) nil)))
+
+
 (defn test-setv-get []
   "NATIVE: test setv works on a get expression"
   (setv foo [0 1 2])
Repository: hylang/hy

Issue:
(del) should not be an error for symmetry with (setv)
Assuming #902 is accepted, can we also have `(del)` be a no-op? `del` already accepts multiple arguments, because Python's `del` does. It makes no sense in Python to have an empty `del` statement, but, again, in Hy, with macros, it's one more special case to look out for.



Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1298,9 +1298,15 @@ def compile_attribute_access(self, expr):
         return ret
 
     @builds("del")
-    @checkargs(min=1)
     def compile_del_expression(self, expr):
-        expr.pop(0)
+        root = expr.pop(0)
+        if not expr:
+            result = Result()
+            result += ast.Name(id='None', ctx=ast.Load(),
+                               lineno=root.start_line,
+                               col_offset=root.start_column)
+            return result
+
         ld_targets, ret, _ = self._compile_collect(expr)
 
         del_targets = []


Test patch:
diff --git a/tests/native_tests/language.hy b/tests/native_tests/language.hy
--- a/tests/native_tests/language.hy
+++ b/tests/native_tests/language.hy
@@ -1092,7 +1092,8 @@
   (del (get test 4))
   (assert (= test [0 1 2 3]))
   (del (get test 2))
-  (assert (= test [0 1 3])))
+  (assert (= test [0 1 3]))
+  (assert (= (del) nil)))
 
 
 (defn test-macroexpand []
Repository: hylang/hy

Issue:
Multiple implementations overwrite each others' entrypoint hooks
It's not uncommon to find Python 2 and Python 3 coexisting on the same system, and it's not unreasonable for the user to also want Hy for both Pythons. However, where Python handles this gracefully by providing separate executables (`python2` and `python3` alongside `python`, `pip2` and `pip3` alongside `pip` etc) Hy simply bulldozes an existing `hy`, `hyc` etc.

Sorry if this has already been reported; I tried to look for previous issues but nothing much came to mind when I was trying to play guess-the-keyword.

Multiple implementations overwrite each others' entrypoint hooks
It's not uncommon to find Python 2 and Python 3 coexisting on the same system, and it's not unreasonable for the user to also want Hy for both Pythons. However, where Python handles this gracefully by providing separate executables (`python2` and `python3` alongside `python`, `pip2` and `pip3` alongside `pip` etc) Hy simply bulldozes an existing `hy`, `hyc` etc.

Sorry if this has already been reported; I tried to look for previous issues but nothing much came to mind when I was trying to play guess-the-keyword.



Discussion:

Resolving patch:
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -52,6 +52,8 @@
 if os.name == 'nt':
     install_requires.append('pyreadline==2.0')
 
+ver = sys.version_info[0]
+
 setup(
     name=PKG,
     version=__version__,
@@ -59,8 +61,11 @@
     entry_points={
         'console_scripts': [
             'hy = hy.cmdline:hy_main',
+            'hy%d = hy.cmdline:hy_main' % ver,
             'hyc = hy.cmdline:hyc_main',
+            'hyc%d = hy.cmdline:hyc_main' % ver,
             'hy2py = hy.cmdline:hy2py_main',
+            'hy2py%d = hy.cmdline:hy2py_main' % ver,
         ]
     },
     packages=find_packages(exclude=['tests*']),


Test patch:
Repository: hylang/hy

Issue:
make defreader use a length-one string instead of a symbol as first argument
Try using `defreader` to make a `#.` or a `#"` or a `#:`, and you'll see the issue. There are probably other special characters that won't work.

``` Hy
(env-hy) C:\Python34\Scripts\env-hy>hy --spy
hy 0.11.0 using CPython(v3.4.3:9b73f1c3e601) 3.4.3 on Windows
=> (defreader . [expr] "spam")
  File "<stdin>", line 1, column 12

  (defreader . [expr] "spam")
             ^
LexException: Malformed dotted list

=> (defreader " [expr] "spam")
... "
KeyboardInterrupt
=> (defreader : [expr] "spam")
```

[long traceback omitted]

It's still possible to work around this if you know the Python expansion:

``` Hy
=> (defreader ^ [expr] "spam")
import hy

@hy.macros.reader('^')
def _hy_anon_fn_1(expr):
    return 'spam'
=> #^"eggs"
'spam'
'spam'
```

And translate it to Hy:

``` Hy
=> #@((hy.macros.reader ".") (fn [expr] "spam"))
@hy.macros.reader('.')
def _hy_anon_fn_1(expr):
    return 'spam'
=> #@((hy.macros.reader ":") (fn [expr] "spam"))
@hy.macros.reader(':')
def _hy_anon_fn_1(expr):
    return 'spam'
=> #@((hy.macros.reader "\"") (fn [expr] "spam"))
@hy.macros.reader('"')
def _hy_anon_fn_1(expr):
    return 'spam'
```

Then they work just fine, so it shouldn't be a difficult fix:

``` Hy
=> #."eggs"
'spam'
'spam'
=> #:"eggs"
'spam'
'spam'
=> #""eggs"
'spam'
'spam'
```

As you can see, the `#"` messes up highlighting, so that should be fixed too.

Instead, you should be able to write 

``` Hy
(defreader "." [expr] "spam")
```



Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -2456,7 +2456,7 @@ def compile_reader(self, expression):
         NOT_READERS = [":", "&"]
         if name in NOT_READERS or len(name) > 1:
             raise NameError("%s can't be used as a macro reader symbol" % name)
-        if not isinstance(name, HySymbol):
+        if not isinstance(name, HySymbol) and not isinstance(name, HyString):
             raise HyTypeError(name,
                               ("received a `%s' instead of a symbol "
                                "for reader macro name" % type(name).__name__))


Test patch:
diff --git a/tests/native_tests/reader_macros.hy b/tests/native_tests/reader_macros.hy
--- a/tests/native_tests/reader_macros.hy
+++ b/tests/native_tests/reader_macros.hy
@@ -37,6 +37,15 @@
   (assert (= (, 1 2 3) a)))
 
 
+(defn test-reader-macro-string-name []
+  "Test if defreader accepts a string as a macro name."
+
+  (defreader "." [expr]
+    expr)
+
+  (assert (= #."works" "works")))
+
+
 (defn test-builtin-decorator-reader []
   (defn increment-arguments [func]
     "Increments each argument passed to the decorated function."
Repository: hylang/hy

Issue:
PyPy now handles reverse ASTs
Basically, I tried removing the code in `hy/compiler.py` that sets the line and column numbers of all the AST nodes on PyPy to 1. And...guess what?

It works.

The tests pass for me. Even more interesting, the issue in #742 where lines go crazy doesn't happen, so PyPy actually works _better_ with Hy than CPython! (This is leading me to believe that the line issue is a CPython bug!)

My idea is to figure out which version of PyPy it is that fixed this and not clear the position data on the newer versions. Thoughts?



Discussion:
I wouldn't bother to support multiple PyPy versions. If it's working on the latest PyPy, I'd say just drop the PyPy specific code.

+1 for going with the latest.


Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -2583,11 +2583,6 @@ def hy_compile(tree, module_name, root=ast.Module, get_expr=False):
     `last_expression` is the.
     """
 
-    if hasattr(sys, "subversion"):
-        implementation = sys.subversion[0].lower()
-    elif hasattr(sys, "implementation"):
-        implementation = sys.implementation.name.lower()
-
     body = []
     expr = None
 
@@ -2607,12 +2602,6 @@ def hy_compile(tree, module_name, root=ast.Module, get_expr=False):
 
     ret = root(body=body)
 
-    # PyPy _really_ doesn't like the ast going backwards...
-    if implementation != "cpython":
-        for node in ast.walk(ret):
-            node.lineno = 1
-            node.col_offset = 1
-
     if get_expr:
         expr = ast.Expression(body=expr)
         ret = (ret, expr)


Test patch:
Repository: hylang/hy

Issue:
fix setup.py
at least hy.extra is missing from package data


Discussion:

Resolving patch:
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -71,6 +71,7 @@
     package_data={
         'hy.contrib': ['*.hy'],
         'hy.core': ['*.hy'],
+        'hy.extra': ['*.hy'],
     },
     author="Paul Tagliamonte",
     author_email="tag@pault.ag",


Test patch: