04:34 <johnjaye> is _immutable_fields_ an rpython construct of some kind?

05:28 <larstiq> in the sense that you use it to tell rpython which fields to treat as immutable

05:33 <larstiq> see e.g. https://foss.heptapod.net/pypy/pypy/-/blob/branch/default/rpython/annotator/classdesc.py#L528

05:49 <johnjaye> oh ok

05:50 <larstiq> how so?

05:59 <johnjaye> how so what

06:01 <larstiq> why are you asking

06:14 <johnjaye> i'm reading some python code from pypy and I realized it's not python. it's rpython

06:15 <johnjaye> like at one point it says globals()[foo]=bar which literally creates variables with the value of foo from a list of strings

06:15 <johnjaye> also there's import statements that go import rpython.stuff

06:16 <johnjaye> but supposedly any rpython is valid python. so maybe that's a valid python construct somehow

06:21 <larstiq> right, rpython is a restricted subset of python

06:22 <johnjaye> well i don't know too much about it. or how pypy works. is that heptapod repo the main pypy?

06:23 <mattip> yes

06:23 <larstiq> you _can_ run pypy on top of cpython, and this is in fact how many tests work (see https://doc.pypy.org/en/latest/coding-guide.html#id29, "By default, they run on top of an untranslated PyPy which runs on top of the host interpreter. ")

06:25 <mattip> rpython is a subset of python2, so you need to use a python2 interpreter as the host

06:27 <mattip> the reason it is a subset is so that the rpython code can be annotated and translated into C

06:27 <mattip> so the definition of RPython is a bit fluid: anything that can be supported by the translation toolchain

06:27 <mattip> so there are two modes to tests:

06:28 <larstiq> where the rule of thumb is, the more dynamic it gets the less likely it's rpython?

06:28 <mattip> - pure python tests ("own" tests) that run in python

06:29 <mattip> - "translated" tests that run after translation

06:29 <mattip> "the more dynamic it gets" - yes, for instance closures are not supported in RPython

07:45 <arigato> johnjaye: for the example of globals()[foo]=bar: that is very dynamic and not RPython at all if done inside a function, but we do that at import time. RPython is a two-step language: first, we import all modules and do sometimes very dynamic stuff to set up all functions and global constants etc., and then the remaining functions must not do anything dynamic any more, so that their code can be translated to efficient C code

07:45 <arigato> in other words, globals()[foo]=bar is normal Python (you can do that in plain Python)

09:13 <fijal> I just had the most strange pip invocation

09:14 <fijal> as soon as I pressed enter, the power went off and it started hailing

09:14 <fijal> like, as I pressed enter

09:42 <larstiq> that's just a tad bit worse than my pip invocations stalling forever with the new resolver algorithm

14:33 <johnjaye> arigato: oh ok so it's fine intially but then not afterward in any functions.

14:36 <johnjaye> so if i understand rpython correctly, it is a subset of python where type inference is possible. this is then used with rpython libraries to make an interpreter for your language defined in EBNF or whatever.