An approach to reduce repetitive code of projections

[DmT021]

Hello! I'm looking at the examples in the tour about different kinds of subscript accessors. I find this concept awesome, however I'd like to see code of subscript to be less repetitive. At least for trivial cases.
Let's take a look at the example:

type Angle {
  public var radians: Double
  public memberwise init
  
  public property degrees: Double {
    let {
      radians * 180.0 / Double.pi
    }
    inout {
      var d = radians * 180.0 / Double.pi
      yield &d
      radians = d * Double.pi / 180.0
    }
    set {
      &radians = new_value * Double.pi / 180.0
    }
  }
}

We don't have sink here, however we wrote word "radians" 4 times, wrote the transformation from degrees to radians two times and the inverse transformation 2 times. Would be nice to have another way to express the same code without repetitions.

An approach I'm thinking about is to introduce concepts of source, transformTo and transformFrom (very rough draft):

  public property degrees: Double {
    source: \.radians // getting address of accessors for the underlying source without actually accessing it
    transformTo(s) {
      source * 180.0 / Double.pi
    }
    tranformFrom(d) {
      d * Double.pi / 180.0
    }
  }

And the real accessors could be synthesized from this definition:

• let { transformTo(generatedSourceAccessor) }

• inout {
    var t = transformTo(generatedSourceAccessor)
    yield &t
    generatedSourceAccessor = transformFrom(t)
  }
  

• set { generatedSourceAccessor = transformFrom(new_value) }

[dabrahams]

You don't need to write the inout accessor explicitly as it can be synthesized from set and let, which are just shorter ways to spell your transformFrom and transformTo.

[DmT021]

Cool, IMO rules about what can be syntesized from what should be highlighted in the tour.
A side question then: the tour says

A mutable subscript can always be used immutably as well.
...
Here, the immutable variant of the subscript is synthesized from the mutable one.

How is that guaranteed? For example if we have an inout that mutates the underlying storage twice:

inout {
  yield &source
  &source *= 2
}

How could we syntesize the immutable variant from this? Or is this prohibited?

[kyouko-taiga]

The tour is oversimplifying.

We can make it work if we ensure that the subscript doesn't write to any inout storage before or after yield. Modifying local storage is fine. That would outlaw your example.

[kyouko-taiga]

But we should probably remove this note from the tour. We will likely implement this feature in the future, but the compiler is currently not smart enough to do that.

[DmT021]

So the correct version is what @dabrahams said: we can synthesize inout from set+let, but not vice versa?

[kyouko-taiga]

Yep.