A modern programming language that makes developers happier.

kotlinlang

Is there a way to use `where` clause when defining `typealiases` ?

Maybe not with that exact ordering, but tell us an example of what you want

I’m exploring interface composition
```interface HasId {
  val id: String
}

interface HasName {
  val name: String
} 

fun &lt;T&gt; doSomething(data: T): Unit where T : HasId, T : HasName {
  // whatever
} ```
This gets cumbersome when you have multiple functions. I would like to define typealias once and use it for multiple functions
```typealias Data = HasId &amp; HasName```

what you want is similar to what this thread describes <https://kotlinlang.slack.com/archives/C0B9K7EP2/p1589398414110200?thread_ts=1589398414.110200>

You can define a interface instead of typealias
```interface Data: HasId, HasName```
or use reified for type checking as demonstrated in this <https://medium.com/androiddevelopers/reification-of-the-erased-41e246725d2c|blog>, the required part being <https://gist.github.com/yenerm/4ff23c907b56fe72f5b32e51a1ae0f8e#file-reified-kt>

<@U0FCV4RND> I do want that, but for another use case. For this case, I need a sort of a sum type that allows defining multiple interface constraints.
```data class RootData() : HasId, HasName, HasProp1, HasProp2```
The idea is to select only partial data without having to map from data type to another. So, I could select only `HasId` and `HasProp1` without having to ask for the whole `RootData` object.  The interface solution doesn’t work well because then `RootData` would need to implement `Data` interface which would couple data to all the places consuming it (I would prefer the data to not be aware where it is consumed).