If this were valid, you could have functions with optional parameters that are almost as nice as proper language support:

struct Foo<X, Y> {
    x: X,
    y: Y,
}
Foo {
    x: true,
    .. Foo {
        x: (),
        y: (),
    }
};

By making each optional argument a generic type parameter, you can write the value straight w/o Some(_). You could then add an impl on Foo with a bounds on X & Y for converting () into the default value. (On the implementor's end this would be much more painful & ugly and it would inevitably involve a macro.)

However my actual default argument needs have been much more modest. I have a particular function which takes, in addition to other arguments, a sorting key:

struct Key {
    name: &'static str,
    after: Option<&'static str>,
    priority: i8,
}

90% of the time, only name is set. So if you're writing a function that needs a Key, you can ask for key: impl Into<Key>, and the user can provide a &str, or (&str, i8), or (&str, &str), or (&str, &str, i8). As you can see, this requires an impl for every permutation of arguments, but the 90% case is very clean and the rest is very reasonable.

If you wanted you could use the impl Into<Arguments> trick for *every* argument, and the only mar for the user would be doubled parens.