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

Gradle Community

I need to add a mapper to my extension, I tried

```    public fun mapVersion(transform: (GradleVersion) -&gt; String) {
        mapper.set(
            object : VersionValueSource.Mapper {
                override fun map(version: GradleVersion, gitData: GitData): String {
                    return transform(version)
                }
            },
        )
    }```
But it is not working.

`Action&lt;GradleVersion&gt;` is not enough as I need to return a `String` and it only allows `Unit`.

Is there something similar to that `Action` but allowing changing the return type?

The stacktrace:

```Caused by: org.gradle.internal.snapshot.ValueSnapshottingException: Couldn't populate class com.javiersc.semver.project.gradle.plugin.SemverExtension$mapVersion$mapper$1```

There's `org.gradle.api.Transformer`, but I don't think it will help with value snapshotting

is VersionValueSource an implementation of `org.gradle.api.provider.ValueSource`?

```internal val versionMapper: Property&lt;VersionMapper&gt; =
    objects
        .property&lt;VersionMapper&gt;()
        .convention(VersionMapper { version -&gt; version.toString() })
internal val versionAndGitMapper: Property&lt;VersionAndGitMapper&gt; =
    objects
        .property&lt;VersionAndGitMapper&gt;()
        .convention(VersionAndGitMapper { version, _ -&gt; version.toString() })
public fun mapVersion(transform: VersionMapper) {
    versionMapper.set(transform)
}
public fun mapVersion(transform: VersionAndGitMapper) {
    versionAndGitMapper.set(transform)
}```

Probably I can use `Transformer` instead of fun interfaces to ensure compatibility in Groovy

Well, with `Transformer` I cannot have a lambda with multiple params, right?

I thought that ValueSource instances had to be created with `ProviderFactory.of()`, do they really work if you create them as a functional interface?

the mappers are the functional interface and I am passing them to the parameters

```            project.providers.of(VersionValueSource::class) { valueSourceSpec -&gt;
                val gitDir = project.provider { project.semverExtension.gitDir.get().asFile }
                valueSourceSpec.parameters.versionMapper.set(project.semverExtension.versionMapper)
                valueSourceSpec.parameters.versionAndGitMapper.set(```

oh sorry, I misread, thanks for clarifying

A `Transformer` is not serializable so it cannot be passed to the source params