**On the link limit:**

Idk how easy or hard it its to configure domain-based exceptions. You can just `wrap them in these`

and let the humans do the work of copy-pasting. We’d rather that than have spambots spamming links.

Can values only occupy the universe of built-in atomic data types like float and string?

Yes.

The right answer to your conceptual (sorry) questions will be found in the TypeQL paper & the video. But here’s one tl;dr view of things:

**What are concepts?**

A simplified view (and one that I use most of the time) is that types, things & values are all concepts, which occupy different spaces. Each ‘thing’ has a type. An attribute is a thing which also has a value.

You can see concepts as the vertices in the graph or as the ‘terms’ in a predicate-logic view. A `get`

query should be returning a `ConceptMap`

. These to me resemble a `substitution`

in logic or the mapping that the ‘Graph Pattern Matching’ problem describes. Though there doesn’t seem to be a standard definition, it usually looks like [1]

A `fetch`

seems less principled but easier to use in software applications where you likely already have to deal with data from API in JSON formats. It’s made under the assumption that the IDs of the vertices aren’t really interesting, but the attributes are. You can see `fetch`

as a post-query step where you use a `match`

find the concept you’re interested in, and then `fetch`

its attributes.

The handy part is that it can return lists of attributes in a single result (& other arbitrarily nested structures), whereas `get`

would have to return one result per item in a list.

[1] Given a graph `G=(V,E,Lv: V -> Tv, Le: E -> Te)`

, and a pattern graph `P=(V', E', L'v: V' -> Tv, L'e: E' -> Te) `

, the results of the pattern matching of P on G is a set of mappings mapping `Mi: V' -> V`

such that `L'v(v) = Lv(Mi(v))`

and `L'e( (u,v) ) = Le( M(u), M(v))`

`V`

is the set of vertices, `E`

is the set of edges - ordered pairs of vertices, `Lv`

is a mapping of vertices to vertex-labels , `Le`

is a mapping of edges to edge-labels.

Ofcourse, In TypeDB the labels are replaced by types, which are slightly more complicated, though the basic idea should remain the same.

The idea of a substitution in logic is similar. It’s a mapping from ‘variables’ to ‘terms’ which make a ‘formula’ true in a given ‘theory’ .