Is there a way to allow builder type inference with a default value if the type isn't inferable? For example,

interface Builder<T> {
   fun initialValue(value: T)
   fun otherMethodsThatWithoutT()
}

fun <T> build(block: Builder<T>.()->Unit) = 
   BuilderImpl<T>().apply(block)

val buildWithType = build { initialValue(0.0) } // T = Double
bal buildWithouType = build { } // Default T to Unit

default values for generic types isn't available, so your best bet would be to create a second function or value. best bet would be:

val build = BuilderImpl<Unit>()
fun build() = BuilderImpl<Unit>()

I've tried having a second function, but then overload doesn't work.

fun <S> sketch(build: SketchBuilder<S>.() -> Unit) {
    SketchBuilderImpl<S>().apply(build)
}

fun sketch(build: SketchBuilder<Unit>.() -> Unit) {
    SketchBuilderImpl<Unit>().apply(build)
}

fun makeSketches() {
    sketch {
        // `this` is SketchBuilder<Unit>
    }

    sketch {
        initialState("") // compiler error: type mismatch, expected Unit, got String
    }
    sketch<String> {
        // `this` is SketchBuilder<String>, but  annoying to have to put the type here
        initialState("")
    }
}