type annotation with Optional

[ghost]

Allô,

I am working with a Python Arcade example. I am not sure how to express one assignment; it includes a type annotation with Optional.

self.physics_engine: Optional[PymunkPhysicsEngine] = None

I got this to work.

(setv (annotate self.physics_engine [None PymunkPhysicsEngine]) None)

Is this the best way to handle this or can I use Optional?

Merci.

[Kodiologist]

Using Optional is a matter of taste, but it can certainly be done. Remember that get is how you index things in Hy. For example,

x: Optional[int] = 1

is written

(setv (annotate x (get Optional int)) 1)

You may also like the macro of in Hyrule.

[ghost]

Personally, when I read (get Optional int), it seems to be saying "reach into Optional and get the int item". In other words, there seems to be clash between what it is doing and what is it saying. Both of the following seem more clear.

This one spells-out the meaning.
(setv (annotate x (Optional int)) 1)

This one explicitly lists the allowed types.
(setv (annotate x [None int]) 1)

Is it just me or is this use of get confusing?

[Kodiologist]

Personally, when I read (get Optional int), it seems to be saying "reach into Optional and get the int item".

That's an issue with Python itself, not Hy. (get x y) is translated exactly to x[y]. You can still make a macro with your preferred syntax (or use of), if you like.

[ghost]

I see: (get Optional int) is translated to Optional[int] I am coming from Scheme, so this looks odd. Yes, I can make a macro to improve readability (well, from my point of view).

[ the macro's quote breaks code formatting ]

(defmacro Optional [a-type] `[None ~a-type])
(setv (annotate aaa (Optional int)) 1)

If I do this, I will want to allow many types, not just one.

[goyalyashpal]

the collection types in python also use this sq bracket syntax for type annotation:

a: list[str] = ['3', '2', '6']
b: tuple[int, int] = (2, 1)
c: dict[str, list[int]] = {}

(defmacro Optional [a-type] `[None ~a-type])
(setv (annotate aaa (Optional int)) 1)

- @ ClaudeM at #2456 (reply in thread)

so, rather than a macro for "Optional"; better would be to create a macro for something like "Parametric Type" (edit: yeah, typeParam looks perfect) or something on similar lines; so, resulting would likely become smth like:

; (from typing import Optional) ;; Invalid
(import typing [Optional Union])

; (setv (annotate x (get Optional int)) 1)
(setv (annotate x (typeParam Optional int)) 1)

(sorry if snake case is not used in hy/lisp)

for my above shared example: E&OE:

(setv (annotate a (typeParam list str)) ["3" "2" "6"])

(setv (annotate b (typeParam tuple [int int])) #(2 1)) 
; ain't sure about how to get commas 😅 as typeParam tuple [int int] 
; will likely translate to double brackets: b: tuple[[ int, int ]]
; but for sake of illustration - let's SAY that [int int] is the correct syntax

(setv (annotate c (typeParam dict [str (typeParam list int)])) {})
; well, i am clueless here about how to nest it 😅 

[goyalyashpal]

doing it in raw with Spy mode (show equivalent Python) ON:

(setv (annotate a (get list str)) ["3" "2" "6"])
(setv (annotate b (get tuple [int int])) #(2 1)) 
(setv (annotate c (get dict [str (get list str)])) {"a" ["b" "c"] "b" ["c" "d"]} )

a: list[str] = ['3', '2', '6']
b: tuple[[int, int]] = (2, 1)
c: dict[[str, list[str]]] = {'a': ['b', 'c'], 'b': ['c', 'd']}
None

[goyalyashpal]

You may also like the macro of in Hyrule.
- @ Kodiologist at #2456 (comment)

Couldn't figure out make of work - always kept showing AttributeError: module 'hyrule.misc' has no attribute 'of'

(import hyrule)(hyrule.misc.of str)

(import hyrule [misc])(misc.of str)

---

ain't sure about how to get commas [inside brackets)
- @ me at https://github.com//discussions/2456#discussioncomment-6202254

But anyways, at least the solution for this was mentioned there :)

; Expanded & indented
(setv 
    (annotate 
        c 
        (get dict #(str (get list str))) ) 
    {"a" ["b" "c"] "b" ["c" "d"]} )

(setv (annotate b (get tuple #(int int))) #(2 1)) 
(setv (annotate c (get dict #(str (get list str))) ) {"a" ["b" "c"] "b" ["c" "d"]} )

b: tuple[int, int] = (2, 1)
c: dict[str, list[str]] = {'a': ['b', 'c'], 'b': ['c', 'd']}
None

---

Refs:

(of T x y ...) (where the ... represents zero or more arguments) will become (get T #(x y ...))

• The Hyrule manual hyrule.misc.of : (of Dict str str) --> Dict[str, str]
  https://hyrule.readthedocs.io/en/master/index.html?highlight=type#hyrule.misc.of
• "of" ain't a unique search term really 😅
  https://hyrule.readthedocs.io/en/master/search.html?q=type
• (import hyrule [inc]) --> from hyrule import inc
  https://docs.hylang.org/en/master/tutorial.html?highlight=Hyrule#hyrule

[Kodiologist]

of is a macro. It needs to be required, not imported. Read the Hy tutorial.

[goyalyashpal]

(require hyrule.misc [of])

;hy.macros.require('hyrule.misc', None, assignments=[['of', 'of']], prefix='')

(of int)

;int
;<class 'int'>

#_ "Expanded & indented"
(setv 
    (annotate 
        c (of dict str (of list str)) )
    {"a" ["b" "c"] "b" ["c" "d"]} )

---

just for my records, experimented with several others too:

(require hyrule)(hyrule.misc.of int) ; vx
(require hyrule.misc)(misc.of int)   ; vx
(require hyrule [misc])(misc.of int) ; xx
(require hyrule.misc.of)(of int)     ; xx