Should we use a simplified Clarity syntax for maps definition?

[LNow]

As you probably know Clarity official documentation says that map definition should look like this:
(define-map map-name ((key-name-0 key-type-0) ...) ((val-name-0 val-type-0) ...))

We know that tuples can be defined also with curly braces, therefore we use following syntax:
(define-map map-name {key-name-0: key-type-0, ...} {val-name-0 val-type-0, ...} )

and our maps are defined like this:

(define-map UserRoles
  {user: principal}
  {roles: uint}
)

(define-map PermissionRoles
  {permission: (string-ascii 50)}
  {roles: uint}
)

@friedger pointed out that we could use a simplified syntax that does not require defining names in tuples. If we would use it our code would look like this:

(define-map UserRoles principal uint)

(define-map PermissionRoles (string-ascii 50) roles: uint)

And maps usage would change from this:

(define-read-only (get-roles (user principal)) 
  (default-to u0 (get roles (map-get? UserRoles {user: user})))
)

(define-public (grant-role (user principal) (role uint))
  (begin
    (asserts! (can-execute tx-sender PERMISSION_GRANT_ROLE) ERR_UNAUTHORIZED)
    (asserts! (> u128 role) ERR_ROLE_OUT_OF_RANGE)
    (asserts! (not (has-role user role)) ERR_ROLE_ALREADY_GRANTED)
    (let
      (
        (currentRoles (get-roles user))
        (newRole (pow u2 role))
      )
      (map-set UserRoles
        {user: user}
        {roles: (+ currentRoles newRole)}
      )
      (ok true)
    )
  )
)

into something like this:

(define-read-only (get-roles (user principal)) 
  (default-to u0 (map-get? UserRoles user))
)

(define-public (grant-role (user principal) (role uint))
  (begin
    (asserts! (can-execute tx-sender PERMISSION_GRANT_ROLE) ERR_UNAUTHORIZED)
    (asserts! (> u128 role) ERR_ROLE_OUT_OF_RANGE)
    (asserts! (not (has-role user role)) ERR_ROLE_ALREADY_GRANTED)
    (let
      (
        (currentRoles (get-roles user))
        (newRole (pow u2 role))
      )
      (map-set UserRoles user (+ currentRoles newRole))
      (ok true)
    )
  )
)

Syntax is shorter but less explicit.

What I would like to know what are your preference when it comes to maps definition syntax?
Shorter and more concise or the longer one that is more explicit?
Or maybe you prefer any other option not mentioned here?

[JMKJR]

Good point of discussion and nicely framed :)

I prefer the shorter syntax and I disagree that it's "less explicit" just because it's less wordy. I actually find it more explicit since it better resembles map usage in other programming languages. For other languages, you don't provide an argument of {key: keyName} to a map call, you just pass the keyName and the method signature already knows it's the key. I found it confusing when I was first learning clarity that a tuple representing the key is passed as an argument to basic map calls. Seemed wordy, confusing, and unconventional.

Should this be a @labs3/standards discussion though instead of a daoOS discussion? Either way, we may need to update the standards there if this results in a change of policy.