From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

And of course trying to set the field via the `build.gradle.kts` resulted in all sorts of complaints.

There are samples about nesting extensions in the Gradle docs (I am from mobile I cannot link them now)

A followup would be -- is there a way to support a set of some extension object -- e.g.
```interface OuterExtension {
  val setOfSetElement: Set&lt;SetElementExtension&gt;
}

interface SetElementExtension {
  val someBool = Property&lt;Boolean&gt;
  val someString = Property&lt;String&gt;
}```

I'm not quite sure what the `build.gradle.kts` syntax would look like to set this in a natural way since I'd need to create an instance somehow to add via `add`

```outerExtension {
  setOfSetElement {
    add(???)
  }
}```


just add a regular function,
```interface Outer Extension {
  fun setOfSetElement(action: Action&lt;SetOfSetElement&gt;) {
    action.execute(setOfSetElement)
  }
}```

:thank_you: -- I ended up finding examples doing just that and it worked great...

<@U06F2SEPNQ0> Can you provide a final implementation of the nested extension with lazy evaluation? I am struggling with the same problem

I ended doing:
```abstract class TestExtensions {
    abstract val enableLocking: Property&lt;Boolean&gt;
    abstract val resolveConsistently: Property&lt;Boolean&gt;

    @get:Nested
    abstract val coverage: JacocoCoverageExtension
    fun coverage(action: Action&lt;JacocoCoverageExtension&gt;) {
        action.execute(coverage)
    }

    init {
        enableLocking.convention(true)
        resolveConsistently.convention(true)
    }
}```
I am not sure if Nested does something but it works

Yeah -- that was primarily it... I'm not 100% sure I'm using lazy eval for the nested elements, but I think it boiled down to the extension just being a normal member, not wrapped as Propert&lt;...&gt; etc.