Hahaha! You tell 'em!
We've already established in a different thread that my memory is like a sieve, but I think the story is something like this: The Europeans were talking about exposing the Javascript dictionary data structure to users, because it's very efficient. I didn't like the idea because we had started with the idea of providing just a minimal toolkit that would still be quite adequate to allow users to invent their own programming language features, namely, first class functions, with which users can invent any control structure, and first class lists, with which they can invent any data structure. We bragged that we could make a serious computer science language by adding just eight blocks to Scratch.
In particular, our theory as teachers was that kids would learn a lot of computer science by building their own implementations of the things that those inferior programming languages (not Scratch, I mean Python and JS and that crowd) led them to believe had to be provided by the programming language wizards -- for example, that you can't do object oriented programming unless you're using a special object oriented language. But also that even something as simple as a FOR loop had to be provided as a special syntax in the language.
Since then, though, we have been slowly creeping toward being more like those other languages, providing everything under the sun as primitive. Dictionaries are an example of that, and a particularly egregious one because it's really quite easy to implement a dictionary as a list of key-value pairs. (See ASSOC in the file utilities library.) But that implementation is slow if you have a large dictionary -- 10,000 entries, say. The Javascript implementation uses hash tables, for constant-time lookup. (You can build hash tables in Snap!, too, efficiently, but the code is no longer trivial.)
So we were disagreeing, and then they proposed a compromise: Dictionaries would look to users just like lists of key-value pairs; you could make one out of two columns of a spreadsheet, for example. The dictionary would look just like a two-column spreadsheet, but could be accessed by giving nonnumeric first inputs to ITEM. You could use the dictionary just like any other list; for example, you could MAP over its key-value pairs and get a new dictionary.
This is way better, I'm mostly convinced, than having an entirely separate dictionary data type. But I still miss the days when we were all about proving how little you need in your language to support building your own dictionaries or whatever.
You're just too accustomed to Scratch. :~) All our other input slot types let you put any expression into them, and if your expression reports a value that isn't in the domain of the function you're calling, that's a runtime error, not a syntactic error caught in advance. In Scratch, whose data types are mostly just numbers and text (Booleans are allowed in very limited contexts), they could realistically have the goal of never showing the user an error message, but instead preventing the user from making the error in the first place. But in Snap!, that restriction on typing non-digits into a numeric block is this strange exception. And it gets in the way of using exact rational or complex inputs to arithmetic operations.