Add sugar for single source DerivedState

[TG-Techie]

Percieved Issue

I often find myself making a Derived state that only depends on one source state and think the full DerivedState(<source>, <fn or lambda>) is a bit clunky and gets in the way of writing readable, declarative code.

Possible Solution

I've been playing around with a few possible syntaxes and would appreciate some input.

1. Directional >> as source >> <transfrom>
2. Explicit .derive or.into, as source.derive(<transfrom>)
3. call syntax source(<transfrom>)

I think there should only be one option. let's explore what they might look like for formatting an int into a string, a pretty general use case.

@singleinstance
class Application(Layout):
    how_much = State(0.5)

    body = VSplit(
        Label(text=how_much<new syntax>str),
        Slider(value=how_much),
    )

    def _any_(self): self.body(center, self.dims)

Chevron and Call

I've been leaning towards the chevron syntax as I think it shows the derived state as a transformation from one state into another. For example:

    Label(text=how_much >> str),

shows that the label takes how_much transformed into a string, I think this is clear and concise.
However, python has some restrictions when it comes to chevrons with lambdas and requires parens or some delimiters.

    Label(text=how_much >> (lambda a: f"{round(a, 3)}")),
or
    Label(text=how_much >> {lambda a: f"{round(a, 3)}"}),

in this case I think the call syntax may be more clear for lambdas...

    Label(text=how_much(lambda a: f"{round(a, 3)}")),

but is less clear for simple transformations.

    Label(text=how_much(str)),

And I think this option is too close to forward method call syntax and may be more confusing for users, they shouldn't have to understand the framework to use it.

I don’t think there should be two options.

Small Aside

One cool thing about using the chevron is they could be chained together...

    Label(text=how_much >> (lambda hm: hm*100) >> round >> str),

Explicit or no change

It may be that verbose is the best option, maybe.

    Label(text=how_much.derive(str))
or
    Label(text=how_much.derive(lambda a: f"{round(a, 3)}"))

While both of these are clear I think they have two drawbacks. The first is you have to stop and think about what they are doing. Secondly, this requires a new-comer to understand what deriving state is.
Though into is a bit better...

    Label(text=how_much.into(str))
or
    Label(text=how_much.into(lambda a: f"{round(a, 3)}"))

and can both be read cleanly, "text equals how_much turned into a string" and "text equals how_much into this function"

Trial Implementation

to try any of these out add this to the body of tg_gui_core.stateful.State

    def derive(self, transform):
        return DerivedState(self, transform)
    __rshift__ = __call__ = into = derive

[electricalhog]

After looking at the different options, I think the chevron syntax both looks the nicest and is just explicit enough. I remember that you don't want the end-user to know how States work or even that they're using them. That syntax makes it clear that the variable is being forwarded to the lambda or function without revealing the underlying framework that makes it work. I don't see the need for parens as an issue, it might even make it visually clearer by isolating the lambda from the variable.

[TG-Techie]

cool! It'll be included in the new_internals branch