A modern programming language that makes developers happier.

kotlinlang

But I don't really want to, I want it to cast everything to Any if the user doesn't provide the value

I don't know anything about your use case, but that sounds like a terrible user experience to me in the Kotlin world.

How does the DSL use that type param? If it matches a function arg, then maybe setting its default value to `Any()` is what you want?

The DSL uses the type param to return a `Sequence&lt;T&gt;`. Inside the DSL, the values of `T` may share a common type `Y`. I want to return `Sequence&lt;Y&gt;` if they do, and `Sequence&lt;Any&gt;` if they don't

It's for something like:
```
class Y
class A : Y
class B : Y

buildSequence&lt;Y&gt; {
      creatingValue&lt;A&gt; { A() }
      creatingValue&lt;B&gt; { B() }
}
```

The compiler can't infer the type this way, and I didn't want the user to be forced to write `buildSequence&lt;Y&gt;`, just `buildSequence { }` which would return `Sequence&lt;Y&gt;`

And perhaps for the user `Sequence&lt;Any&gt;` is enough

Messing around type projections or bounds might be what you’re after, though I’m not familiar enough with them to know if they will fit this use-case <https://kotlinlang.org/docs/reference/generics.html#variance>

I tried to mess with many of them :confused:

Perhaps I"m overthinking this, and there's no problem in typing `buildSequence&lt;Any&gt;` if the user wants it

Try to use this annotation. It may help.
`@BuilderInference`

E.g. there is this code building a `Flow&lt;T&gt;`:
```
public fun &lt;T&gt; flow(@BuilderInference block: suspend FlowCollector&lt;T&gt;.() -&gt; Unit): Flow&lt;T&gt; = SafeFlow(block)
```
Just by calling `emit(instancOfMyType)` in the provided lambda (argument to `block`), the compiler can infer that `T` is `MyType`

<https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-builder-inference/index.html>

And the example is practically my use case

How can I use the `@Experimental` without requiring the compiler flag for the client to use?

I think you’d have to mark this part of your API as experimental as well, since it promises something to the user of your API that only this experimental feature can offer.

Unfortunately it didn't work. still getting the "Not enough information to infer parameter"

It works if I enable the new type inference