Why not have python setattr function instead of use_state

[VatsalJagani]

Starting this discussion which core developers may not like, as I know it involves a lot of work under the whole library again.

Here is how it goes:

• React uses a hook called use_state to change dom when data changes and on the other side it changes the state (data) when the user makes any change to the UI.

• We could try and use Python-like syntax of just updating the variable to a new value without calling the function set_whatever.

• This seems possible with Python as Python has the method __setattr__ which can handle all the changes and do pre-processing or post-processing needed.

• We could do something like:

  • Implementation Idea:

class ReactPyData:
    def __init__(self, value=None):
        self.val = value

    def __setattr__(self, name, value)
        if name == "val":
            self.val = value

* Usage:

from reactpy import ReactPyData

mydataobj = ReactPyData()
mydataobj.val = 10

student_list = ReactPyData( [ {"name": "Vatsal", "roll_no": 1}, {"name": "Newton", "roll_no": 2} ] )

# Then you could use mydataobj and student_list variable directly into the HTML code as a template

• This would create more Python-like syntax, suitable for people like me who is from a Python background but not from React side.

FYI, I'm not familiar with React JS as much, so I cannot tell for sure if this is possible, but someone knowing React better can tell if this is feasible or not.

[rmorshea]

This reminds me of the signal pattern.

[rmorshea]

With that said, signals don't really seem to have caught on and some of the criticisms seem reasonable to me.

[VatsalJagani]

I think it's a good idea though!!

[rmorshea]

I suspect that we probably will not ship signals in reactpy proper, but as mentioned in that issue, it makes sense to make changes that would allow for them to be implemented. Probably in a dedicated reactpy-signal package.

[Archmonger]

We have looked into this and it is technologically realistic.

The reason we current don't currently do this was a design decision to have a 1:1 match with the ReactJS's API. If Facebook/Meta implements preact-style signals then we will as well.

At least for now, if/when we implement this it will be a separate Python package.

[nanarino]

[email protected] happens to be implemented like this 😎

[nanarino]

but it had to override js array methods push()、pop()、shift()、unshift()、splice()、sort()、reverse()

[rmorshea]

I think imperative patterns are inherently untrustworthy here. Vue itself even lays out a number of caveats. This becomes especially complicated when you aren't dealing with built-in data types (e.g. DataFrames, Numpy arrays) to which these rules would not, and likely could not apply.

Ultimately, explaining to users that mutating your state never triggers updates seems much simpler to understand than saying that, "well sometimes if you do it like this, mutating a value will trigger an update."

[Alan3344]

This python uses a generic version of reference variables, which is similar to Ref in Vue

You can wear any type

But it needs to be integrated into this framework, otherwise the value of the dom element cannot be changed

from typing import Generic, TypeVar

T = TypeVar('T')


class Ref(Generic[T]):
    def __init__(self, value: T = None):
        self._value: T = value

    @property
    def current(self) -> T:
        return self._value

    @current.setter
    def current(self, value: T):
        self._value = value


num = Ref(1)
print(num.current)  # 1
num.current = 2
print(num.current)  # 2

[Archmonger]

If you're interested, you can publish this as a third-party package.

At this time, we don't intend to implement any design patterns that don't already exist in ReactJS.

As a note, we do have a use_ref hook.

[rmorshea]

use_ref utilizes a Ref that's basically identical the one shown above.