A modern programming language that makes developers happier.

kotlinlang

i tend to prefer the following when working with non-traditional class constructors:
```
data class Foo {
    companion object {
        operator fun invoke(): Foo {
        
        }
    }
}
```

yeah, a large portion of it comes down to how unconventional kotlin's companion objects are

<https://kotlinlang.org/docs/reference/type-aliases.html>

I’d probably suggest doing `fun Foo() = Foo(someValue)` instead

For me it looks fine, pretty popular idiom

`fun Foo() = Foo(someValue)`
is also fine, but it will  conflict with class if class has the same signature of constructor, so you cannot have private constructor and builder with some additional logic:
```class Foo private constructor(val value: String)

fun Foo(rawWalue: String?) = Foo(requireNotNull(rawWalue))```

so invoke operator in companion still pretty useful

Isn't `Foo()` via companion object `invoke()` still just as ambiguous if the class has that same constructor?

The same with Foo builder function will not work
<https://pl.kotl.in/fEWGXae7D>

First sample works only with private constructor tho, otherwise it will be ambiguous.  But it’s not a problem, because this invoke operator usually used to hide real constructor