Re: Generics question

On 27.08.23 16:36, Saravanan Palanichamy wrote:
> Jochen,
>
> Thank you for your quick response.
>
> I did consider this, but I want to be able to use a mutable where-ever
> immutable is allowed. For example, if a function can take all immutable
> parameters, I want to be able to call it with mutable types as well. So
> my choices are either bypass typing when I try to use mutable where
> immutables are needed (in addition to dealing with the generics issue I
> called out) or just deal with the generics issue I am looking to solve.
> Either way, I'll have to do something (or am I thinking too much :D)
>
> I specifically want this to work, because my DSL is trying to implement
> ReadOnly constructs so Mutable/Immutable are not really types seen by
> the programmer, its just used during the type checking mechanism to make
> sure something marked @ReadOnly is not modified

for me they are kind of exclusive, but ok.

> So the programmer will type
>
> void fn1(@ReadOnly Entity myInputParameter) {
>      List<Entity> things = []
>      things << myInputParameter
>
>      // This should cause a compile error
>      myInputParameter.myProperty = "1234
> }

that should be possible without much problem. A bit more tricky is

def x = myInputParameter
x.myProperty = "1234"

but still possible I would say. Where it gets really problematic is then

things[0].myProperty = "1234"

> and I want to see
>
> void fn1(Entity.Immutable myInputParameter) {
>      // I want this to work but it wont because of groovy type checking
>      List<Entity.Mutable> things = []
>      things << myInputParameter
>
>      // This will automatically fail (like I want it to) because
> setMyProperty is not a method in immutable and is only available in mutable
>      myInputParameter.myProperty = "1234"
> }

but what, except that you replaced the annotations with two types is now
really different?

But why not extend the annotation idea?

void fn1(@ReadOnly Entity myInputParameter) {
      List<@ReadOnly Entity> things = []
      // only allow if T(myInputParameter) is
      // @ReadOnly Entity
      things << myInputParameter

      // fails because of @ReadOnly
      myInputParameter.myProperty = "1234
      // fails because of propagated @ReadOnly
      things[0].myProperty = "1234"
      // could be allowed or forbidden based
      // on @Readonly
      Entity x = things[0]
      things[0].myProperty = "1234"
}


Frankly I currently don't see how to solve this based on the type system
if you do not want to do it like I suggested.

In general adding restrictions or making something found that is not
found otherwise is easy with the type checking extensions. But to tell
the compiler that something is found but wrong or that something should
be propagated in a different way than usual... that is difficult with
the current infrastructure. One way to solve this would then imho be to
find a version that passes compilation and let that the typechecker
check that instead. And then add your checks for immutability.

bye Jochen