Changes between Version 3 and Version 4 of SemanticQuery/Examples

Timestamp:

Feb 27, 2015, 1:40:32 PM (9 years ago)

Author:

manualwiki

Comment:

mostly sq-type related changes

SemanticQuery/Examples

@@ -100 +100 @@
 mods.funs[is_tail_recursive == non_tail_rec]
 }}}
+
+== Practical example for using "-type", "-spec" related selectors and properties: ==
+Let's say we are new to a project with a large code-base and our task is to implement a new interface in which we have to do some operations on a very complex data structure. The source of this complex structure is remote, but we know there are multiple compatible data structures already implemented, although not sure about the specifics, so we would like to investigate and do this without manually going through several thousand lines of code.
+
+We might start by running the following query:
+{{{
+"files.typerefs"
+}}}
+This gives us all used types in every file. After scrolling to the end of the hundred and something pages of results, we at least know types properly specified, but not much else.
+Maybe we should only look at types defined in "general" modules:
+{{{
+"mods[name ~ \"gen\"].types"
+}}}
+Unfortunately these seem to be either irrelevant or too general for us to use. We decide that we should look at types from other modules by filtering results using the "-spec" attributes (and let's assume, we are looking for a structure that has an "append" function implemented).
+But first we would like to know if "-spec" is used in our modules.
+{{{
+"mods.funs[not (.name in files.specs.name)][loc > 10]"
+}}}
+The query results are promising, it looks like most of the non-trivial functions have a specification.
+We can take a look at returned types of functions named like "append":
+{{{
+mods.funs[name ~ \"append\"].returntype
+}}}
+This query also gives us too many possible results, we are only interested in exported ones:
+{{{
+mods.funs[name ~ \"append\"].returntype[exported]
+}}}
+Turns out most of them were exported. However when we have looked at types from "gen" modules, we may have noticed a type("person") for a structure which is a part of what we have to append to the large structure.
+{{{
+mods.funs[name ~ \"append\"][.params.type.(subtype.(params)+)+[name = 'person']].returntype[exported]
+}}}
+This query only yields return-types of ~"append" functions that have a parameter whose type uses the "person" type.
+If we would like to see in which files these types have been used we could run the following:
+{{{
+mods.funs[name ~ \"append\"][.params.type.(subtype.(params)+)+[name = 'person']].returntype[exported].references.file
+}}}