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

Issue:
read-str raises EOFError given "\"\"", "b\"\"", "[]", or "{}"
Or `"#{}"`.


Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -24,9 +24,9 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-from hy.models import (HyExpression, HyKeyword, HyInteger, HyComplex, HyString,
-                       HyBytes, HySymbol, HyFloat, HyList, HySet, HyDict,
-                       HyCons)
+from hy.models import (HyObject, HyExpression, HyKeyword, HyInteger, HyComplex,
+                       HyString, HyBytes, HySymbol, HyFloat, HyList, HySet,
+                       HyDict, HyCons)
 from hy.errors import HyCompileError, HyTypeError
 
 from hy.lex.parser import hy_symbol_mangle
@@ -2689,7 +2689,10 @@ def hy_compile(tree, module_name, root=ast.Module, get_expr=False):
     body = []
     expr = None
 
-    if tree:
+    if not (isinstance(tree, HyObject) or type(tree) is list):
+        raise HyCompileError("tree must be a HyObject or a list")
+
+    if isinstance(tree, HyObject) or tree:
         compiler = HyASTCompiler(module_name)
         result = compiler.compile(tree)
         expr = result.force_expr
@@ -2697,10 +2700,9 @@ def hy_compile(tree, module_name, root=ast.Module, get_expr=False):
         if not get_expr:
             result += result.expr_as_stmt()
 
-        if isinstance(tree, list):
-            spoof_tree = tree[0]
-        else:
-            spoof_tree = tree
+        # We need to test that the type is *exactly* `list` because we don't
+        # want to do `tree[0]` on HyList or such.
+        spoof_tree = tree[0] if type(tree) is list else tree
         body = compiler.imports_as_stmts(spoof_tree) + result.stmts
 
     ret = root(body=body)


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
@@ -1052,6 +1052,19 @@
   (assert (= None (eval (quote (print ""))))))
 
 
+(defn test-eval-false []
+  (assert (is (eval 'False) False))
+  (assert (is (eval 'None) None))
+  (assert (= (eval '0) 0))
+  (assert (= (eval '"") ""))
+  (assert (= (eval 'b"") b""))
+  (assert (= (eval ':) :))
+  (assert (= (eval '[]) []))
+  (assert (= (eval '(,)) (,)))
+  (assert (= (eval '{}) {}))
+  (assert (= (eval '#{}) #{})))
+
+
 (defn test-eval-globals []
   "NATIVE: test eval with explicit global dict"
   (assert (= 'bar (eval (quote foo) {'foo 'bar})))
@@ -1380,7 +1393,16 @@
 
 (defn test-read-str []
   "NATIVE: test read-str"
-  (assert (= (read-str "(print 1)") '(print 1))))
+  (assert (= (read-str "(print 1)") '(print 1)))
+  (assert (is (type (read-str "(print 1)")) (type '(print 1))))
+
+  ; Watch out for false values: https://github.com/hylang/hy/issues/1243
+  (assert (= (read-str "\"\"") '""))
+  (assert (is (type (read-str "\"\"")) (type '"")))
+  (assert (= (read-str "[]") '[]))
+  (assert (is (type (read-str "[]")) (type '[])))
+  (assert (= (read-str "0") '0))
+  (assert (is (type (read-str "0")) (type '0))))
 
 (defn test-keyword-creation []
   "NATIVE: Test keyword creation"
Repository: hylang/hy

Issue:
`yield` inside `with` can lead to generation of a spurious `return`
it tried to return it, d'oh.

we need to disable return mangling on generator functions



Discussion:
@paultag: could you write some code that failed before, to make sure that it doesn't anymore or that it still does?

still active, bug #205 dupe

(see #205 for the example)

nommy; assigning self

cleared in #246 

I'm still noticing problems with yield when mixed with `with` blocks in the latest release:

```hy
(import contextlib)

(with-decorator contextlib.contextmanager
  (defn test-file-open [filename]
    (with [fp (open filename)]
          (yield fp))))
```

generates

```python
import contextlib

@contextlib.contextmanager
def test_file_open(filename):
    with open(filename) as fp:
        _hy_anon_var_1 = yield fp
    return _hy_anon_var_1
```

and fails to load:

```
SyntaxError: 'return' with argument inside generator
```

And I see it in both python2 and python3.
@vodik That's been brought up somewhere else (though I don't recall where). We really need a way to suppress auto returns...

Meanwhile, I think a good solution would just be disabling auto-returns completely when in a generator...

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1485,6 +1485,7 @@ def compile_with_expression(self, expr):
                                            optional_vars=thing)]
 
         ret = ctx + the_with
+        ret.contains_yield = ret.contains_yield or body.contains_yield
         # And make our expression context our temp variable
         expr_name = ast.Name(id=ast_str(var), arg=ast_str(var),
                              ctx=ast.Load(),


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
@@ -724,6 +724,14 @@
   (with [(open "README.md" "r")] (do)))
 
 
+(defn test-context-yield []
+  "NATIVE: test yields inside of with statements don't try to return before Python 3.3"
+  (defn f []
+    (with [(open "README.md")] (yield 123)))
+
+  (assert (= (next (f)) 123)))
+
+
 (defn test-with-return []
   "NATIVE: test that with returns stuff"
   (defn read-file [filename]
@@ -893,7 +901,7 @@
 
 (defn test-and []
   "NATIVE: test the and function"
-  
+
   (setv and123 (and 1 2 3)
         and-false (and 1 False 3)
         and-true (and)
Repository: hylang/hy

Issue:
Single quote crashes hy2py
## x.hy

```
'
```

## `hy2py x.hy`

```
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "hy/cmdline.py", line 406, in hy2py_main
    if stdin_text is None
  File "hy/cmdline.py", line 186, in pretty_error
    print(e, file=sys.stderr)
  File "hy/lex/exceptions.py", line 43, in __str__
    source = self.source.split("\n")
AttributeError: 'NoneType' object has no attribute 'split'
```


Discussion:

Resolving patch:
diff --git a/hy/lex/__init__.py b/hy/lex/__init__.py
--- a/hy/lex/__init__.py
+++ b/hy/lex/__init__.py
@@ -34,7 +34,7 @@ def tokenize(buf):
     except LexingError as e:
         pos = e.getsourcepos()
         raise LexException("Could not identify the next token.",
-                           pos.lineno, pos.colno)
+                           pos.lineno, pos.colno, buf)
     except LexException as e:
         if e.source is None:
             e.source = buf
diff --git a/hy/lex/exceptions.py b/hy/lex/exceptions.py
--- a/hy/lex/exceptions.py
+++ b/hy/lex/exceptions.py
@@ -24,12 +24,12 @@
 
 class LexException(HyError):
     """Error during the Lexing of a Hython expression."""
-    def __init__(self, message, lineno, colno):
+    def __init__(self, message, lineno, colno, source=None):
         super(LexException, self).__init__(message)
         self.message = message
         self.lineno = lineno
         self.colno = colno
-        self.source = None
+        self.source = source
         self.filename = '<stdin>'
 
     def __str__(self):


Test patch:
diff --git a/tests/test_lex.py b/tests/test_lex.py
--- a/tests/test_lex.py
+++ b/tests/test_lex.py
@@ -63,6 +63,17 @@ def test_unbalanced_exception():
         pass
 
 
+def test_lex_single_quote_err():
+    "Ensure tokenizing \"' \" throws a LexException that can be stringified"
+    # https://github.com/hylang/hy/issues/1252
+    try:
+        tokenize("' ")
+    except LexException as e:
+        assert "Could not identify the next token" in str(e)
+    else:
+        assert False
+
+
 def test_lex_expression_symbols():
     """ Make sure that expressions produce symbols """
     objs = tokenize("(foo bar)")
Repository: hylang/hy

Issue:
REPL history is lost on (quit)
REPL history is not flushed to disk if the REPL is exited using `(quit)`. 

A workaround is to remember to use `CTRL-D` to exit the REPL.

Would be nice if `(quit)` also worked.


Discussion:
Confirmed. Thanks for reporting.
Here is a fix that works if I paste it into the REPL. This should probably be done in Python in the hy history code.

```
(import atexit readline os)
(def hist-file (os.path.expanduser "~/.hy-history"))
(-> hist-file (open "a") (.close))
(atexit.register readline.write_history_file hist-file)
```
That sounds like it could be the start of a great first PR, if you'd like to get involved in Hy.

Resolving patch:
diff --git a/hy/completer.py b/hy/completer.py
--- a/hy/completer.py
+++ b/hy/completer.py
@@ -124,7 +124,8 @@ def completion(completer=None):
 
         readline.parse_and_bind(readline_bind)
 
-    yield
-
-    if docomplete:
-        readline.write_history_file(history)
+    try:
+        yield
+    finally:
+        if docomplete:
+            readline.write_history_file(history)


Test patch:
Repository: hylang/hy

Issue:
`try` form not working in `defmacro`
The simplest possible `try` form?
```Python
=> (try None (except [] None))
try:
    _hy_anon_var_1 = None
except:
    _hy_anon_var_1 = None
_hy_anon_var_1
```
Useless, but it works. Put it in a simple `defmacro`, and
```Hy
=> (defmacro foo [] (try None (except [] None)) `())
  File "<input>", line 1, column 18

  (defmacro foo [] (try None (except [] None)) `())
                   ^-------------------------^
HyTypeError: b"Unknown expression in `try'"
```
What happened?

But it works fine if we substitute in the expected `None`
```Python
=> (defmacro foo [] None `())
import hy
from hy import HyExpression

def _hy_anon_fn_1():
    None
    return HyExpression([])
hy.macros.macro('foo')(_hy_anon_fn_1)
<function _hy_anon_fn_1 at 0x000001B059952488>
```


Discussion:
`deftag` also chokes on this.
```Python
=> (deftag foo [] (try None (except [] None)) `())
  File "<input>", line 1, column 16

  (deftag foo [] (try None (except [] None)) `())
                 ^-------------------------^
HyTypeError: b"Unknown expression in `try'"


=> (deftag foo [] None `())
import hy
from hy import HyExpression

def _hy_anon_fn_1():
    None
    return HyExpression([])
hy.macros.tag('foo')(_hy_anon_fn_1)
<function _hy_anon_fn_1 at 0x000001B0598DEA60>
```
Good find; this is a strange one.

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -23,6 +23,7 @@
 import ast
 import sys
 import keyword
+import copy
 
 from collections import defaultdict
 
@@ -2392,7 +2393,8 @@ def _compile_time_hack(self, expression):
         """Compile-time hack: we want to get our new macro now
         We must provide __name__ in the namespace to make the Python
         compiler set the __module__ attribute of the macro function."""
-        hy.importer.hy_eval(expression,
+
+        hy.importer.hy_eval(copy.deepcopy(expression),
                             compile_time_ns(self.module_name),
                             self.module_name)
 


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
@@ -617,3 +617,10 @@ def test_exec_star():
         assert code.body.s == "print(a + b)"
         assert code.globals.keys[0].s == "a"
         assert code.locals.keys[0].s == "b"
+
+
+def test_compiler_macro_tag_try():
+    """Check that try forms within defmacro/deftag are compiled correctly"""
+    # https://github.com/hylang/hy/issues/1350
+    can_compile("(defmacro foo [] (try None (except [] None)) `())")
+    can_compile("(deftag foo [] (try None (except [] None)) `())")
Repository: hylang/hy

Issue:
Exception in __repr__ crashes repl
```Python
=> (defclass BadRepr[] (defn __repr__ [self] (/ 0)))
class BadRepr:

    def __repr__(self):
        return (1 / 0)
None
=> (BadRepr)
BadRepr()
Traceback (most recent call last):
  File "C:\Users\ME\workspace\hy36-gilch\Scripts\hy-script.py", line 11, in <module>
    load_entry_point('hy', 'console_scripts', 'hy')()
  File "c:\users\me\documents\github\hy\hy\cmdline.py", line 341, in hy_main
    sys.exit(cmdline_handler("hy", sys.argv))
  File "c:\users\me\documents\github\hy\hy\cmdline.py", line 336, in cmdline_handler
    return run_repl(spy=options.spy, output_fn=options.repl_output_fn)
  File "c:\users\me\documents\github\hy\hy\cmdline.py", line 231, in run_repl
    os=platform.system()
  File "C:\Users\ME\AppData\Local\Programs\Python\Python36\lib\code.py", line 233, in interact
    more = self.push(line)
  File "C:\Users\ME\AppData\Local\Programs\Python\Python36\lib\code.py", line 259, in push
    more = self.runsource(source, self.filename)
  File "c:\users\me\documents\github\hy\hy\cmdline.py", line 118, in runsource
    print(self.output_fn(value))
  File "<eval_body>", line 1, in __repr__
ZeroDivisionError: division by zero

(hy36-gilch) C:\Users\ME\Documents\GitHub\hy>
```
It should just report the exception like Python does, not quit the repl.


Discussion:
I probably created this bug when I redid the REPL. It shouldn't be hard to fix: put a `try` around the part of the code that calls the `repl-output-fn` and display any error message in a user-friendly way.

Resolving patch:
diff --git a/hy/cmdline.py b/hy/cmdline.py
--- a/hy/cmdline.py
+++ b/hy/cmdline.py
@@ -115,7 +115,12 @@ def ast_callback(main_ast, expr_ast):
             # the user as `_`.
             self.locals['_'] = value
             # Print the value.
-            print(self.output_fn(value))
+            try:
+                output = self.output_fn(value)
+            except Exception:
+                self.showtraceback()
+                return False
+            print(output)
         return False
 
 


Test patch:
diff --git a/tests/test_bin.py b/tests/test_bin.py
--- a/tests/test_bin.py
+++ b/tests/test_bin.py
@@ -132,6 +132,16 @@ def test_bin_hy_stdin_except_do():
     assert "zzz" in output
 
 
+def test_bin_hy_stdin_bad_repr():
+    # https://github.com/hylang/hy/issues/1389
+    output, err = run_cmd("hy", """
+         (defclass BadRepr [] (defn __repr__ [self] (/ 0)))
+         (BadRepr)
+         (+ "A" "Z")""")
+    assert "ZeroDivisionError" in err
+    assert "AZ" in output
+
+
 def test_bin_hy_stdin_hy_repr():
     output, _ = run_cmd("hy", '(+ [1] [2])')
     assert "[1, 2]" in output.replace('L', '')
Repository: hylang/hy

Issue:
Make `help()` recogonize macros as well
It would be nice to have `help` recogonize macros as well. Ideas welcome...



Discussion:
Could't we just have the docstrings appended to an own dict/method? not completely sure how the macros itself are defined and called, but should't it be possible todo something along the lines of how **doc** works with objects?


Resolving patch:
diff --git a/hy/macros.py b/hy/macros.py
--- a/hy/macros.py
+++ b/hy/macros.py
@@ -34,6 +34,7 @@ def macro(name):
 
     """
     def _(fn):
+        fn.__name__ = "({})".format(name)
         try:
             argspec = getargspec(fn)
             fn._hy_macro_pass_compiler = argspec.keywords is not None
@@ -63,6 +64,7 @@ def tag(name):
 
     """
     def _(fn):
+        fn.__name__ = '#{}'.format(name)
         module_name = fn.__module__
         if module_name.startswith("hy.core"):
             module_name = None


Test patch:
Repository: hylang/hy

Issue:
try form should have implicit do
It's strange that its subforms, `except/finally/else` have an implicit do, but the `try` form itself does not. After popping off any of the expected subforms at the end, the rest of the forms of the `try` body could be put in a `do` block, couldn't they?


Discussion:
I guess that's right. It would be similar to how `for` (and now `while`) have an implicit `do` possibly terminated by `else`.

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -843,8 +843,14 @@ def compile_try_expression(self, expr):
         expr = copy.deepcopy(expr)
         expr.pop(0)  # try
 
-        # (try something…)
-        body = self.compile(expr.pop(0) if expr else [])
+        # (try something somethingelse…)
+        body = Result()
+        # Check against HyExpression and HySymbol to avoid incorrectly
+        # matching [except ...] or ("except" ...)
+        while expr and not (isinstance(expr[0], HyExpression)
+                            and isinstance(expr[0][0], HySymbol)
+                            and expr[0][0] in ("except", "else", "finally")):
+            body += self.compile(expr.pop(0))
 
         var = self.get_anon_var()
         name = asty.Name(expr, id=ast_str(var), ctx=ast.Store())


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
@@ -515,10 +515,16 @@
 
   (try (do) (except [IOError]) (except))
 
+  ; test that multiple expressions in a try get evaluated
+  (setv value 0)
+  (try (+= value 1) (+= value 2)  (except [IOError]) (except))
+  (assert (= value 3))
+
   ;; Test correct (raise)
   (setv passed False)
   (try
    (try
+    (do)
     (raise IndexError)
     (except [IndexError] (raise)))
    (except [IndexError]
@@ -650,7 +656,25 @@
       (setv x 45))
     (else (setv x 44)))
    (except))
-  (assert (= x 0)))
+  (assert (= x 0))
+
+  ; test that [except ...] and ("except" ...) aren't treated like (except ...),
+  ; and that the code there is evaluated normally
+  (setv x 0)
+  (try
+    (+= x 1)
+    ("except" [IOError]  (+= x 1))
+    (except))
+
+  (assert (= x 2))
+
+  (setv x 0)
+  (try
+    (+= x 1)
+    [except [IOError]  (+= x 1)]
+    (except))
+
+  (assert (= x 2)))
 
 (defn test-earmuffs []
   "NATIVE: Test earmuffs"
Repository: hylang/hy

Issue:
document eval-when-compile and eval-and-compile
These two have empty entries in docs. Fill them in and maybe explain where they are useful.


Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -2081,22 +2081,15 @@ def compile_dispatch_tag_macro(self, expression):
         expr = tag_macroexpand(tag, expression.pop(0), self)
         return self.compile(expr)
 
-    @builds("eval_and_compile")
-    def compile_eval_and_compile(self, expression):
+    @builds("eval_and_compile", "eval_when_compile")
+    def compile_eval_and_compile(self, expression, building):
         expression[0] = HySymbol("do")
         hy.importer.hy_eval(expression,
                             compile_time_ns(self.module_name),
                             self.module_name)
-        expression.pop(0)
-        return self._compile_branch(expression)
-
-    @builds("eval_when_compile")
-    def compile_eval_when_compile(self, expression):
-        expression[0] = HySymbol("do")
-        hy.importer.hy_eval(expression,
-                            compile_time_ns(self.module_name),
-                            self.module_name)
-        return Result()
+        return (self._compile_branch(expression[1:])
+                if building == "eval_and_compile"
+                else Result())
 
     @builds(HyCons)
     def compile_cons(self, cons):


Test patch:
Repository: hylang/hy

Issue:
1e1000 should not be a symbol
Hy counts `1e308` as a floating-point number, but `2e308` as a symbol. 
```Python
=> (type 1e308)
type(1e+308)

<class 'float'>
=> (type 2e308)
type(2e308)

Traceback (most recent call last):
  File "c:\users\me\documents\github\hy\hy\importer.py", line 201, in hy_eval
    return eval(ast_compile(expr, "<eval>", "eval"), namespace)
  File "<eval>", line 1, in <module>
NameError: name '2e308' is not defined
```

This is inconsistent. Float literals that are too large should be `inf`, because that's how Python does it.
```Python
>>> 1.7e308
1.7e+308
>>> 1.8e308
inf
```


Discussion:
Sounds like a bug in my code for checking the capitalization of `Inf`.

Resolving patch:
diff --git a/hy/models.py b/hy/models.py
--- a/hy/models.py
+++ b/hy/models.py
@@ -179,7 +179,7 @@ def __new__(cls, number, *args, **kwargs):
 
 def check_inf_nan_cap(arg, value):
     if isinstance(arg, string_types):
-        if isinf(value) and "Inf" not in arg:
+        if isinf(value) and "i" in arg.lower() and "Inf" not in arg:
             raise ValueError('Inf must be capitalized as "Inf"')
         if isnan(value) and "NaN" not in arg:
             raise ValueError('NaN must be capitalized as "NaN"')


Test patch:
diff --git a/tests/test_lex.py b/tests/test_lex.py
--- a/tests/test_lex.py
+++ b/tests/test_lex.py
@@ -103,6 +103,12 @@ def test_lex_expression_float():
     assert objs == [HyExpression([HySymbol("foo"), HyFloat(1.e7)])]
 
 
+def test_lex_big_float():
+    # https://github.com/hylang/hy/issues/1448
+    assert tokenize("1e900") == [HyFloat(1e900)]
+    assert tokenize("1e900-1e900j") == [HyComplex(1e900, -1e900)]
+
+
 def test_lex_nan_and_inf():
 
     assert isnan(tokenize("NaN")[0])
Repository: hylang/hy

Issue:
Support relative imports (PEP 328)
Module names with a leading dot need to have that dot stripped:

```clojure
(disassemble '(import [.foo [bar]]))
```

Incorrectly generates `ImportFrom(module='.foo', names=[alias(name='bar', asname=None)], level=0)`, but `module` should be `"foo"` (no dot).

And 

```clojure
(disassemble '(import [. [bar]]))
```

Generates `ImportFrom(module='.', names=[alias(name='bar', asname=None)], level=0)` when `module` should be `None`.


Discussion:

Resolving patch:
diff --git a/hy/compiler.py b/hy/compiler.py
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1156,10 +1156,17 @@ def compile_import_expression(self, expr):
         def _compile_import(expr, module, names=None, importer=asty.Import):
             if not names:
                 names = [ast.alias(name=ast_str(module), asname=None)]
+
+            ast_module = ast_str(module)
+            module = ast_module.lstrip(".")
+            level = len(ast_module) - len(module)
+            if not module:
+                module = None
+
             ret = importer(expr,
-                           module=ast_str(module),
+                           module=module,
                            names=names,
-                           level=0)
+                           level=level)
             return Result() + ret
 
         expr.pop(0)  # index


Test patch:
diff --git a/tests/native_tests/__init__.hy b/tests/native_tests/__init__.hy
deleted file mode 100644
diff --git a/tests/native_tests/__init__.py b/tests/native_tests/__init__.py
new file mode 100644
--- /dev/null
+++ b/tests/native_tests/__init__.py
@@ -0,0 +1,3 @@
+# Note that __init__.py is intentional so pytest (more specifically py.path)
+# will detect us as a Python package. There's logic there that involves looking
+# specifically for this file.
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
@@ -1812,3 +1812,8 @@ macros()
   (defn f4 [[a b]] "not a docstring")
   (assert (none? (. f4 __doc__)))
   (assert (= (f4 [1 2]) "not a docstring")))
+
+(defn test-relative-import []
+  "Make sure relative imports work properly"
+  (import [..resources [tlib]]))
+  (assert (= (tlib.*secret-message* "Hello World")))
diff --git a/tests/resources/tlib.py b/tests/resources/tlib.py
--- a/tests/resources/tlib.py
+++ b/tests/resources/tlib.py
@@ -2,6 +2,9 @@
 from hy import HyList, HyInteger
 
 
+SECRET_MESSAGE = "Hello World"
+
+
 @macro("qplah")
 def tmac(ETname, *tree):
     return HyList((HyInteger(8), ) + tree)