It's difficult to design a language that has implicit arguments *and* allows you to explicitly instantiate them. Agda has done very admirably.

But I do not like bound names, which are often single letters, getting undeservedly elevated to names that play a descriptive role.

My maxim is:

If you see {A = A} in an argument list, they blew it.

There is something very honest about the way this is dealt with in Rocq, oversimplified below:

1. Implicitness of arguments is a "calling convention" that is configured for each defined function.

2. If you want to deviate from the implicit calling convention of a named function, you use an `@` sigil before the function, and then all arguments become explicit.

I like this a bit more because it discourages you from making things implicit that you frequently have to supply explicitly. Very quickly you learn whether your API is realistic in light of the unifier.

@jonmsterling A frustration that I find with Rocq is that, for inductives and records, often one wants the parameters(/indices) to be explicit for the type constructor but implicit for the data constructors/projectors. There are solutions to this but none are particularly elegant.