Does this work? [[:db/add 987654321 :bar/link [:foo/uname+uid ["domain" "123456"]]]]. I suspect it’s just ambiguity in the map desugaring--it’s trying to interpret it as a list of entity refs instead of one large entity ref. That map->attribute stuff is not aware of what attributes mean.

Hello, Yes it works. Thanks. Nonetheless, it works with regular lookup refs, like [:foo/internal-name "plop"] , it works well. I tried to change the type of :foo/uname from string to keyword, and now am getting the following error:

...
Caused by datomic.impl.Exceptions$IllegalArgumentExceptionInfo
   :db.error/not-an-entity Unable to resolve entity: :domain
   {:cognitect.anomalies/category :cognitect.anomalies/incorrect,
    :cognitect.anomalies/message "Unable to resolve entity: :domain",
    :entity :domain,
    :db/error :db.error/not-an-entity}

The map syntax is syntax sugar and the syntax is inherently ambiguous. Also on-prem has this “auto-keywordization” feature where you can put a string where a keyword is expected (e.g. “:foo”) and it will coerce to a keyword. (This was added I think so using datomic from java is easier. Cloud doesn’t have it. It makes things worse here.) So what should {:foo [:bar ["box" "baz"]]} mean? Is it [:db/add ID :foo :bar][:db/add ID foo [:box "baz"]]? (the only possible interpretation before tuples were added.) Or is it [:db/add ID :foo [:bar ["box" "baz"]]?

For backward compatibility, I think it has to be [:db/add ID :foo :bar][:db/add ID :foo [:box "baz"]]

And your puzzling stacktrace is because [:db/add ID :foo [:box "baz"]] doesn’t make sense. It tried to turn the “domain” in ["domain" "123456"] into a keyword via auto-keywordization and couldn’t.

But since idents have types, the [:db/add ID :foo :bar][:db/add ID foo [:box "baz"]] case couldn't be possible since :foo would have a :db/valueType :db.type/keyword type in the first assertion and a :db/valueType :db.type/ref type in the second. So the only valid case would be [:db/add ID :foo [:bar ["box" "baz"]] after tuples introduction and error before, no ... ?

the desugaring is purely syntatic

it doesn’t have a DB to introspect types

Ah ok, I see.

also, [:db/add ID :foo :bar][:db/add ID :foo [:box "baz"]] is indeed possible if :foo is a ref

:bar is a valid entity ref

so is [:box "baz"]

so is 12345

and in assertion contexts, so is -123 (temp id) or #db/id{:part :some-partition-kw :idx -1} (a tempid record object)

A keyword can be a ref? I didn't know. In which case?

so even if you used types, it wouldn’t help much

:db/ident establishes a keyword as a ref

that’s how attribute lookup works

Ah yes. I see.

https://docs.datomic.com/on-prem/schema/identity.html#entity-identifiers

Thanks a lot for all the information. I solved my problem with a little function:

(defn entity->attr-list [entity]
  (let [id (or (:db/id entity)
               (d/tempid :db.part/user))]
    (->> (dissoc entity :db/id)
         (mapv (fn [[key value]]
                 [:db/add id key value])))))

Humm may be not so simple for idents with "many" cardinality...

yes, nor nested maps

or reverse refs

if you are really attached to the map syntax except for this one handling of tuple values, consider annotating the tuple ref with metadata and expanding only those map entries via a postwalk

That's a lot of complexity for the map syntax. I'll change my code to explicitly format transaction statements without ambiguity. The standard way.

that’s what I recommend

👌 Thanks

sugar gives you cavities

😂 I see. Too much sugar at least.