Analyzer tags are used to identify how a solution was solved.
These tags can then be used to:
A tag is a string that is formatted as: <category>:<thing>
.
We support four different categories, going from highest to lowest level:
Category  Description  Specificity  Examples 

paradigm 
A programming paradigm  Very highlevel, not trackspecific 
imperative , functional

technique 
A technique being used  Highlevel, most won't be trackspecific 
recursion , immutability

construct 
A language construct  Many won't be trackspecific 
bitwiseand , forloop

uses 
Languagespecific usage, like types or methods  Lowlevel, trackspecific 
DateTime.add_seconds , IEnumerable

Some example tags:
paradigm:functional
technique:recursion
construct:bitwiseand
uses:DateTime.add_seconds
Whilst tracks are free to tag solutions as they see fit, we recommend trying to use the below list of commonly used tags when possible. Using a common set of tags will allow us to do some nifty things, like crosstrack linking of solutions.
Tag  Description 

paradigm:declarative 
uses declarative programming. 
paradigm:functional 
uses functional programming. 
paradigm:generic 
uses generic programming. 
paradigm:imperative 
uses imperative programming. 
paradigm:logic 
uses logic programming. 
paradigm:meta 
uses metaprogramming. 
paradigm:objectoriented 
uses objectoriented programming. 
paradigm:procedural 
uses procedural programming. 
paradigm:reflective 
uses reflective programming. 
paradigm:stackoriented 
uses stackoriented programming. 
Tag  Description 

technique:bitmanipulation 
manipulates bits, usually via bitwise operators (e.g. AND, XOR or left shift) 
technique:bitshifting 
shifts bits in a number 
technique:booleanlogic 
executes boolean logic (AND, OR, NOT) 
technique:composition 
uses composition 
technique:concurrency 
runs code concurrently 
technique:enumeration 
enumerates over values 
technique:errorhandling 
handles errors 
technique:exceptions 
catches or throws exceptions 
technique:functioncomposition 
uses function composition 
technique:generator 
uses a generator 
technique:higherorderfunctions 
uses higherorder functions 
technique:immutability 
uses immutability 
technique:immutablecollection 
uses a collection whose contents are immutable 
technique:inheritance 
uses inheritance 
technique:laziness 
produces values lazily, only when needed 
technique:locks 
uses locks to get exclusive access to resources 
technique:looping 
uses loops 
technique:math 
uses math 
technique:memorymanagement 
manages memory 
technique:ordering 
orders data 
technique:parallelism 
runs code in parallel 
technique:parser 
parses data 
technique:pointers 
uses pointers 
technique:randomness 
uses randomness 
technique:recursion 
uses recursion 
technique:regularexpression 
uses regular expressions 
technique:shortcircuiting 
uses shortcircuiting to prevent unnecessary evaluation 
technique:sortedcollection 
uses a collection whose elements are always sorted 
technique:sorting 
sorts data 
technique:tailcalloptimization 
uses tailcall optimization for efficient recursion 
technique:typeconversion 
converts values from one type to another type 
technique:unsafe 
uses unsafe code (for example pointer arithmetic) 
Tag  Description 

construct:abstractclass 
defines an abstract class 
construct:abstractmethod 
defines an abstract method 
construct:addassignment 
combines addition with assignment 
construct:add 
uses addition 
construct:array 
uses or declares an array 
construct:assignment 
assigns or binds a value to a variable/name 
construct:asyncawait 
uses async /await

construct:attribute 
annotates a member with metadata 
construct:autoimplementedproperty 
defines an autoimplemented property 
construct:biginteger 
uses a big integer 
construct:binarynumber 
defines a number in binary notation 
construct:bitarray 
uses or declares a bit array 
construct:bitwiseandassignment 
combines a bitwise AND with assignment 
construct:bitwiseand 
executes a bitwise AND 
construct:bitwiseleftshiftassignment 
combines a bitwise left shift with assignment 
construct:bitwiseleftshift 
executes a bitwise left shift 
construct:bitwisenot 
executes a bitwise NOT 
construct:bitwiseorassignment 
combines a bitwise OR with assignment 
construct:bitwiseor 
executes a bitwise OR 
construct:bitwiserightshiftassignment 
combines a bitwise right shift with assignment 
construct:bitwiserightshift 
executes a bitwise right shift 
construct:bitwisexorassignment 
combines a bitwise XOR with assignment 
construct:bitwisexor 
executes a bitwise XOR 
construct:block 
defines a block containing a list of statements 
construct:boolean 
defines or uses a boolean value 
construct:boxing 
uses boxing 
construct:break 
breaks from a loop 
construct:byte 
uses an unsigned 8bit integer 
construct:catch 
catches an exception 
construct:char 
uses a character 
construct:checkedarithmetic 
uses checked arithmetic (which guards against overflows) 
construct:class 
defines a class 
construct:collectioninitializer 
sets a collection's values via an initializer 
construct:command 
defines a command 
construct:comment 
defines a comment 
construct:comparisonchaining 
chains comparison calls 
construct:comparison 
compares two values for their relative order 
construct:complexnumber 
uses a complex number 
construct:computedstring 
defines a computed string 
construct:concatenation 
concatenates values 
construct:conditionalaccess 
accesses a method conditionally 
construct:conditionaloperator 
uses a ternary conditional operator 
construct:conditional 
executes code conditionally 
construct:constant 
defines a constant (immutable) value 
construct:constructor 
defines a constructor 
construct:continue 
continues to the next iteration of a loop 
construct:conversionoperator 
defines a conversion operator 
construct:copy 
copies a value 
construct:coroutine 
defines or uses a coroutine 
construct:customattribute 
defines a custom attribute 
construct:datetime 
uses a value that represents a combination of date and time 
construct:date 
uses va value that represents a date (no time) 
construct:decimal 
uses a 128bit floatingpoint number 
construct:decrement 
decrements a value 
construct:defaultinterfaceimplementation 
defines default implementation in an interface 
construct:default 
defines a default value (e.g. for a parameter) 
construct:destructuring 
decontructs a value into its parts 
construct:dictionarycomprehension 
creates a dictionary via a comprehension 
construct:dictionary 
uses/defines a dictionary/map 
construct:discard 
uses the special discard value 
construct:divideassignment 
combines division with assignment 
construct:divide 
uses division 
construct:dowhileloop 
uses a dowhile loop 
construct:double 
uses a 64bit floatingpoint number 
construct:else 
defines an else branch 
construct:enum 
defines or uses an enum (enumeration of values) 
construct:equality 
compares the equality of two values 
construct:error 
defines or uses an error 
construct:event 
defines or uses events 
construct:exception 
defines or uses exceptions 
construct:explicitconversion 
converts from one type to another type explicitly 
construct:explicitimport 
imports only select functionality 
construct:exponentiation 
calculates the exponentiation of a value 
construct:expressionbodiedmember 
defines an expressionbodied member 
construct:extensionmethod 
defines an extension method 
construct:fieldaccess 
accesses a field 
construct:field 
defines a field 
construct:finally 
uses finally to ensure that a specific code block always runs 
construct:flagsenum 
defines or uses a flag enum 
construct:float 
uses a 32bit floatingpoint number 
construct:floatingpointnumber 
uses a floatingpoint number 
construct:forloop 
uses a for loop 
construct:foreach 
uses a foreach loop 
construct:functionoverloading 
uses function overloading 
construct:function 
defines a function 
construct:generator 
defines a generator function or method 
construct:genericfunction 
defines a function that is parameterized with one or more types 
construct:genericmethod 
defines a method that is parameterized with one or more types 
construct:generictype 
defines type that is parameterized with one or more types 
construct:getter 
defines a getter 
construct:globalfunction 
defines a function that is available globally 
construct:globalvariable 
defines a variable that is available globally 
construct:header 
defines a header file 
construct:hexadecimalnumber 
defines a number in hexadecimal notation 
construct:if 
uses an if statement 
construct:implicitconversion 
converts from one type to another type implicitly 
construct:implicitloop 
loops over a collection of values implicitly 
construct:implicitreturn 
returns a value implicitly 
construct:import 
imports functionality implemented elsewhere (e.g. from a namespace/module) 
construct:increment 
increments a value 
construct:indexoperator 
defines an operator for indexing an object 
construct:indexer 
defines or uses an indexer 
construct:indexing 
accesses a value by index 
construct:inequality 
compares the inequality of two values 
construct:infixoperator 
defines an infix operator 
construct:initialization 
initializes an object after creation 
construct:initializerlist 
initializes the values of an object's fields 
construct:initializer 
initializes an object 
construct:instance 
creates or uses an instance of a type 
construct:instantiation 
creates an instance of a type 
construct:int 
uses a signed 32bit integer 
construct:integralnumber 
uses an integral number (integer) 
construct:interface 
defines an interface 
construct:invocation 
invokes a method/function 
construct:iterator 
defines a function or method that can be iterated over 
construct:jaggedarray 
uses a jagged array (an array of arrays) 
construct:lambda 
defines a lambda (aka an "anonymous function") 
construct:linkedlist 
uses a linked list 
construct:linq 
uses LINQ 
construct:listcomprehension 
builds a list via a comprehension 
construct:list 
uses a list 
construct:localfunction 
defines a local function 
construct:localvariable 
defines a local variable 
construct:lock 
uses a lock 
construct:logicaland 
executes a logical AND 
construct:logicalnot 
executes a logical NOT 
construct:logicalor 
executes a logical OR 
construct:long 
uses a signed 64bit integer 
construct:loop 
defines a loop 
construct:macro 
defines a macro 
construct:membershiptest 
tests a value for membership in another value 
construct:metatable 
defines a metatable 
construct:methodchaining 
chains several method calls 
construct:methodoverloading 
uses method overloading 
construct:methodoverride 
defines an overridden method 
construct:method 
defines a method 
construct:module 
defines a module (grouping of code) 
construct:moduloassignment 
combines division remainder with assignment 
construct:modulo 
uses division remainder 
construct:multidimensionalarray 
uses an array with multiple dimensions 
construct:multilinestring 
defines a multiline string 
construct:multipleassignment 
assigns multiple values at once 
construct:multipledispatch 
uses multiple dispatch 
construct:multiplyassignment 
combines multiplication with assignment 
construct:multiply 
uses multiplication 
construct:namedargument 
passes an argument by name 
construct:namespace 
defines a namespace (grouping of code) 
construct:nestedfunction 
defines a nested function 
construct:nestedtype 
defines a nested type 
construct:nesting 
uses nesting 
construct:nint 
uses a signed platformspecific integer (32 or 64bit) 
construct:nuint 
uses an unsigned platformspecific integer (32 or 64bit) 
construct:null 
uses null/nil to represents the absence of a value 
construct:nullability 
deals with null/nil values 
construct:number 
uses a number (signed or unsigned) 
construct:objectinitializer 
sets an object's values via an initializer 
construct:octalnumber 
defines a number in octal notation 
construct:operatoroverloading 
uses operator overloading 
construct:option 
uses an option type 
construct:optionalparameter 
defines an optional parameter 
construct:overflow 
uses arithmetic overflow 
construct:parameter 
defines a parameter 
construct:parenthesizedexpression 
encloses an expression in parentheses 
construct:patternmatching 
uses pattern matching 
construct:pattern 
defines a pattern uses in pattern matching 
construct:pipebackward 
uses a backward pipe 
construct:pipeforward 
uses a forward pipe 
construct:pipeline 
defines a pipeline 
construct:pointfree 
defines functions without the arguments they operate on 
construct:pointer 
uses a pointer 
construct:postfixdecrement 
decrements a value using postfix notation 
construct:postfixincrement 
increments a value using postfix notation 
construct:prefixdecrement 
decrements a value using prefix notation 
construct:prefixincrement 
increments a value using prefix notation 
construct:print 
prints a value to the console 
construct:property 
defines a property (getter/setter) 
construct:queryexpression 
queries data via an expression 
construct:queue 
uses a queue 
construct:range 
defines a range 
construct:readonly 
defines a readonly value 
construct:record 
defines a record 
construct:regularexpression 
defines or uses a regular expression 
construct:result 
uses a result type 
construct:returntype 
defines the return type of a function or method 
construct:return 
returns from a function/method 
construct:sbyte 
uses a signed 8bit integer 
construct:scientificnotationnumber 
defines a number in scientific notation 
construct:setcomprehension 
creates a set via a comprehension 
construct:set 
uses a set 
construct:setter 
defines a setter 
construct:short 
uses a signed 16bit integer 
construct:slice 
uses a slice 
construct:stack 
uses a stack 
construct:staticfield 
defines a static field 
construct:staticmethod 
defines a static method 
construct:stringformatting 
builds a string via a format string 
construct:stringinterpolation 
defines an interpolated string 
construct:string 
defines a string 
construct:struct 
defines a struct 
construct:subtractassignment 
combines subtraction with assignment 
construct:subtract 
uses subtraction 
construct:sumtype 
defines a sum type 
construct:switch 
uses a switch

construct:table 
defines a table 
construct:templatealias 
defines an alias for a template 
construct:templateparameter 
defines a template parameter 
construct:template 
defines a template 
construct:throw 
throws an exception 
construct:time 
uses an object that represents the time 
construct:try 
handles an exception explicitly 
construct:tuple 
uses a tuple 
construct:typealias 
defines an alias for a type 
construct:typeconversion 
converts (casts) a value to another type 
construct:typeextension 
extends a type with new functionality 
construct:typeinference 
infers the type of a value/function automatically 
construct:typetest 
test if a value has a specific type 
construct:uint 
uses an unsigned 32bit integer 
construct:ulong 
uses an unsigned 64bit integer 
construct:unaryminus 
uses a unary minus 
construct:unaryplus 
uses a unary plus 
construct:underscorednumber 
uses a number with underscores as its digit separators 
construct:uniontype 
defines a union type 
construct:userdefinedexception 
defines a custom, userdefined exception 
construct:ushort 
uses an unsigned 16bit integer 
construct:usingdirective 
uses code from another file 
construct:usingstatement 
assigns and disposes a value via the using statement 
construct:varargs 
defines a parameter that supports passing in zero or more values 
construct:variable 
declares variable 
construct:vector 
uses a vector 
construct:verbatimstring 
uses a verbatim string (no escape sequences) 
construct:virtualmethod 
defines a virtual method 
construct:visibilitymodifiers 
specifies the visibility of a construct (e.g. a method or class) 
construct:whileloop 
uses a while loop 
construct:yield 
yields a value in a loop lazily 
As this category is languagespecific, there are no commonly used tags here.