Αdding support for Q# language

components.json

@@ -985,6 +985,12 @@
 			"alias": "py",
 			"owner": "multipetros"
 		},
+		"qsharp": {
+			"title": "Q#",
+			"require": "clike",
+			"alias": "qs",
+			"owner": "fedonman"
+		},
 		"q": {
 			"title": "Q (kdb+ database)",
 			"owner": "Golmote"

components/prism-qsharp.js

@@ -0,0 +1,168 @@
+(function (Prism) {
+
+	/**
+	 * Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
+	 *
+	 * Note: This is a simple text based replacement. Be careful when using backreferences!
+	 *
+	 * @param {string} pattern the given pattern.
+	 * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
+	 * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
+	 * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
+	 */
+	function replace(pattern, replacements) {
+		return pattern.replace(/<<(\d+)>>/g, function (m, index) {
+			return '(?:' + replacements[+index] + ')';
+		});
+	}
+	/**
+	 * @param {string} pattern
+	 * @param {string[]} replacements
+	 * @param {string} [flags]
+	 * @returns {RegExp}
+	 */
+	function re(pattern, replacements, flags) {
+		return RegExp(replace(pattern, replacements), flags || '');
+	}
+
+	/**
+	 * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+	 *
+	 * @param {string} pattern
+	 * @param {number} depthLog2
+	 * @returns {string}
+	 */
+	function nested(pattern, depthLog2) {
+		for (var i = 0; i < depthLog2; i++) {
+			pattern = pattern.replace(/<<self>>/g, function () { return '(?:' + pattern + ')'; });
+		}
+		return pattern.replace(/<<self>>/g, '[^\\s\\S]');
+	}
+
+	// https://docs.microsoft.com/en-us/azure/quantum/user-guide/language/typesystem/
+	// https://github.com/microsoft/qsharp-language/tree/main/Specifications/Language/5_Grammar
+	var keywordKinds = {
+		// keywords which represent a return or variable type
+		type: 'Unit Int BigInt Double Bool String Qubit Result Range true false Zero One Pauli PauliI PauliX PauliY PauliZ Adj Ctl',
+		// keywords which are used to declare a type
+		typeDeclaration: 'newtype',
+		// all other keywords
+        other: 'Adjoint adjoint and apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new not open operation or repeat return self set until use using while within'
+    } 
+	// keywords
+	function keywordsToPattern(words) {
+		return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b';
+	}
+	var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);
+	var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other));
+	var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.other);
+
+	// types
+	var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2); // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.
+	var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
+	var name = /@?\b[A-Za-z_]\w*\b/.source;
+	var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
+	var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [nonTypeKeywords, genericName]);
+	var array = /\[\s*(?:,\s*)*\]/.source;
+	var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [identifier, array]);
+	var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [generic, nestedRound, array])
+	var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
+	var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [tuple, identifier, array]);
+
+	var typeInside = {
+		'keyword': keywords,
+		'punctuation': /[<>()?,.:[\]]/
+	};
+
+	// strings & characters
+	var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source; // simplified pattern
+	var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
+
+    // attributes
+	var regularStringOrCharacter = regularString + '|' + character;
+    var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]);
+
+	Prism.languages.qsharp = Prism.languages.extend('clike', {
+		'string': [
+			{
+				pattern: re(/(^|[^$\\])<<0>>/.source, [regularString]),
+				lookbehind: true,
+				greedy: true
+			},
+			{
+				pattern: RegExp(character),
+				greedy: true,
+				alias: 'character'
+			}
+		],
+		'class-name': [
+			{
+				// open Microsoft.Quantum.Canon;
+				pattern: re(/(\bopen\s+)<<0>>(?=\s*;)/.source, [identifier]),
+				lookbehind: true,
+				inside: typeInside
+			},
+            {
+				// namespace Quantum.App1;
+				pattern: re(/(\bnamespace\s+)<<0>>(?=\s*{)/.source, [identifier]),
+				lookbehind: true,
+				inside: typeInside
+			},
+		],
+		'keyword': keywords,
+		'number': /(?:0(?:x[\da-f_]*[\da-f]|b[01_]*[01]|o[0-7]*[0-7])|(?:\B\.\d*|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+		'operator': /and=|or=|<[-=]|[-=]>|[*^=\-!+\/%=]=?|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|\.\.\.|~~~/,
+		'punctuation': /::|[{}[\];(),.:]/
+	});
+
+	Prism.languages.insertBefore('qsharp', 'number', {
+		'range': {
+			pattern: /\.\./,
+			alias: 'operator'
+		}
+	});
+
+	// string interpolation
+	var formatString = /:[^}\r\n]+/.source;
+
+	// single line
+	var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [regularStringOrCharacter]), 2)
+	var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [sInterpolationRound, formatString]);
+
+	function createInterpolationInside(interpolation, interpolationRound) {
+		return {
+			'interpolation': {
+				pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
+				lookbehind: true,
+				inside: {
+					'format-string': {
+						pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [interpolationRound, formatString]),
+						lookbehind: true,
+						inside: {
+							'punctuation': /^:/
+						}
+					},
+					'punctuation': /^\{|\}$/,
+					'expression': {
+						pattern: /[\s\S]+/,
+						alias: 'language-csharp',
+						inside: Prism.languages.csharp
+					}
+				}
+			},
+			'string': /[\s\S]+/
+		};
+	}
+
+	Prism.languages.insertBefore('qsharp', 'string', {
+		'interpolation-string': {
+			pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]),
+			lookbehind: true,
+			greedy: true,
+			inside: createInterpolationInside(sInterpolation, sInterpolationRound),
+		}
+	});
+
+}(Prism));
+
+Prism.languages.qs = Prism.languages.qsharp;

examples/prism-qsharp.html

@@ -0,0 +1,33 @@
+<h2>Full example</h2>
+<pre><code>namespace Bell {
+  open Microsoft.Quantum.Canon;
+  open Microsoft.Quantum.Intrinsic;
+
+  operation SetQubitState(desired : Result, target : Qubit) : Unit {
+      if desired != M(target) {
+          X(target);
+      }
+  }
+
+  @EntryPoint()
+  operation TestBellState(count : Int, initial : Result) : (Int, Int) {
+
+      mutable numOnes = 0;
+      use qubit = Qubit();
+      for test in 1..count {
+          SetQubitState(initial, qubit);
+          let res = M(qubit);        
+
+          // Count the number of ones we saw:
+          if res == One {
+                set numOnes += 1;
+          }
+      }
+
+      SetQubitState(Zero, qubit); 
+
+  // Return number of times we saw a |0> and number of times we saw a |1>
+  Message("Test results (# of 0s, # of 1s): ");
+  return (count - numOnes, numOnes);
+  }
+}</code></pre>

plugins/autoloader/prism-autoloader.js

@@ -108,6 +108,7 @@
 		],
 		"purebasic": "clike",
 		"purescript": "haskell",
+		"qsharp": "clike",
 		"qml": "javascript",
 		"qore": "clike",
 		"racket": "scheme",
@@ -214,6 +215,7 @@
 		"pbfasm": "purebasic",
 		"purs": "purescript",
 		"py": "python",
+		"qs": "qsharp",
 		"rkt": "racket",
 		"rpy": "renpy",
 		"robot": "robotframework",