Enhanced C#
Language of your choice: library documentation
Public static fields | List of all members
Loyc.Syntax.CodeSymbols Class Reference

A list of common symbols that have special meaning somewhere in Loyc or EC#: operators, built-in data types, keywords, trivia, etc. More...


Source file:

Remarks

A list of common symbols that have special meaning somewhere in Loyc or EC#: operators, built-in data types, keywords, trivia, etc.

Public static fields

static readonly Symbol Mul = GSymbol.Get("'*")
 "*" Multiplication (or dereference)
 
static readonly Symbol Div = GSymbol.Get("'/")
 "/" Division
 
static readonly Symbol Add = GSymbol.Get("'+")
 "+" Addition or unary +
 
static readonly Symbol Sub = GSymbol.Get("'-")
 "-" Subtraction or unary -
 
static readonly Symbol _Dereference = GSymbol.Get("'*")
 Alias for Mul.
 
static readonly Symbol _Pointer = GSymbol.Get("'*")
 Alias for Mul.
 
static readonly Symbol _UnaryPlus = GSymbol.Get("'+")
 Alias for Add.
 
static readonly Symbol _Negate = GSymbol.Get("'-")
 Alias for Sub. Infix and prefix operators use same symbol.
 
static readonly Symbol PreInc = GSymbol.Get("'++")
 "++" Unary prefix increment
 
static readonly Symbol PreDec = GSymbol.Get("'--")
 "--" Unary prefix decrement
 
static readonly Symbol PostInc = GSymbol.Get("'++suf")
 "suf++" Unary suffix increment
 
static readonly Symbol PostDec = GSymbol.Get("'--suf")
 "suf--" Unary suffix decrement
 
static readonly Symbol Mod = GSymbol.Get("'%")
 "%" Remainder operator
 
static readonly Symbol And = GSymbol.Get("'&&")
 "&&" Logical short-circuit 'and' operator
 
static readonly Symbol Or = GSymbol.Get("'||")
 "||" Logical short-circuit 'or' operator
 
static readonly Symbol Xor = GSymbol.Get("'^^")
 "^^" Logical 'xor' operator (tentative–this operator is redundant, "!=" is equivalent)
 
static readonly Symbol Eq = GSymbol.Get("'==")
 "==" Equality test operator
 
static readonly Symbol Neq = GSymbol.Get("'!=")
 "!=" Inequality test operator
 
static readonly Symbol GT = GSymbol.Get("'>")
 ">" Greater-than operator
 
static readonly Symbol GE = GSymbol.Get("'>=")
 ">=" Greater-than-or-equal-to operator
 
static readonly Symbol LT = GSymbol.Get("'<")
 "<" Less-than operator
 
static readonly Symbol LE = GSymbol.Get("'<=")
 "<=" Less-than-or-equal-to operator
 
static readonly Symbol Shr = GSymbol.Get("'>>")
 ">>" Right-shift operator
 
static readonly Symbol Shl = GSymbol.Get("'<<")
 "<<" Left-shift operator
 
static readonly Symbol Not = GSymbol.Get("'!")
 "!" Logical 'not' operator
 
static readonly Symbol Assign = GSymbol.Get("'=")
 "=" Assignment operator
 
static readonly Symbol OrBits = GSymbol.Get("'|")
 "|" Bitwise or operator
 
static readonly Symbol AndBits = GSymbol.Get("'&")
 "&" Bitwise and operator. Also, address-of (unary &)
 
static readonly Symbol _AddressOf = GSymbol.Get("'&")
 Alias for AndBits.
 
static readonly Symbol NotBits = GSymbol.Get("'~")
 Unary bitwise inversion operator.
 
static readonly Symbol _Concat = GSymbol.Get("'~")
 Alias for NotBits. Concat operator in D.
 
static readonly Symbol _Destruct = GSymbol.Get("'~")
 Alias for NotBits.
 
static readonly Symbol XorBits = GSymbol.Get("'^")
 "^" Bitwise exclusive-or operator
 
static readonly Symbol Braces = GSymbol.Get("'{}")
 "{}" Creates a scope.
 
static readonly Symbol IndexBracks = GSymbol.Get("'_[]")
 foo[1, A] <=> <tt>_[](foo, 1, A), but in a type context, Foo[] <=> #of(<tt>[], Foo) More...
 
static readonly Symbol Array = GSymbol.Get("#[]")
 Used for list/array literals. Not used for attributes.
 
static readonly Symbol _Bracks = Array
 Synonym for Array (@#[])
 
static readonly Symbol TwoDimensionalArray = GSymbol.Get("#[,]")
 int[,] <=> #of(<tt>#[,], int)
 
static readonly Symbol Async = GSymbol.Get("#async")
 [#async] Task Foo(); <=> async Task Foo();
 
static readonly Symbol Await = GSymbol.Get("await")
 await(x); <=> await x; (TENTATIVE: should this be changed to #await?)
 
static readonly Symbol NullIndexBracks = GSymbol.Get("'?[]")
 <tt>?[](foo, #(1, A)) <=> foo?[1, A] (TENTATIVE, may be changed later) More...
 
static readonly Symbol InitializerAssignment = GSymbol.Get("'[]=")
 <tt>[]=(0, 1, x) <=> [0, 1]=x
 
static readonly Symbol AltList = GSymbol.Get("#")
 # is used for lists of things in definition constructs, e.g. #class(Derived, #(Base, IEnumerable), {...}). For a time, #tuple was used for this purpose; the problem is that a find-and-replace operation intended to find run-time tuples could accidentally match one of these lists. So I decided to dedicate # for use inside special constructs; its meaning depends on context. More...
 
static readonly Symbol _HashMark = GSymbol.Get("#")
 
static readonly Symbol QuestionMark = GSymbol.Get("'?")
 "?" Conditional operator. (a?b:c) <=> <tt>?(a,b,c) and int? <=> #of(<tt>?, int)
 
static readonly Symbol Of = GSymbol.Get("#of")
 "#of" for giving generic arguments. #of(List,int) <=> List<int>
 
static readonly Symbol Dot = GSymbol.Get("'.")
 "." binary dot operator, e.g. string.Join
 
static readonly Symbol NamedArg = GSymbol.Get("#namedArg")
 "#namedArg" Named argument e.g. #namedarg(x, 0) <=> x: 0
 
static readonly Symbol New = GSymbol.Get("#new")
 "#new": new Foo(x) { a } <=> #new(Foo(x), a); new[] { ... } <=> #new(<tt>[](), ...)
 
static readonly Symbol Out = GSymbol.Get("#out")
 "#out": out x <=> [#out] x
 
static readonly Symbol Ref = GSymbol.Get("#ref")
 "#ref": ref int x <=> [#ref] #var(#int, x)
 
static readonly Symbol Sizeof = GSymbol.Get("#sizeof")
 "#sizeof" sizeof(int) <=> #sizeof(int)
 
static readonly Symbol Typeof = GSymbol.Get("#typeof")
 
static readonly Symbol As = GSymbol.Get("#as")
 "#as": #as(x,string) <=> x as string <=> x(as string)
 
static readonly Symbol Is = GSymbol.Get("#is")
 "#is": #is(x,string) <=> x is string
 
static readonly Symbol Cast = GSymbol.Get("#cast")
 "#cast": #cast(x,int) <=> (int)x <=> x(-> int)
 
static readonly Symbol NullCoalesce = GSymbol.Get("'??")
 "??": a ?? b <=> <tt>??(a, b)
 
static readonly Symbol PtrArrow = GSymbol.Get("'->")
 "->": a->b <=> <tt>->(a, b)
 
static readonly Symbol ColonColon = GSymbol.Get("'::")
 "::" Scope resolution operator in many languages
 
static readonly Symbol Lambda = GSymbol.Get("'=>")
 "=>" used to define an anonymous function
 
static readonly Symbol Default = GSymbol.Get("#default")
 "#default" for the default(T) pseudofunction in C#
 
static readonly Symbol NullCoalesceAssign = GSymbol.Get("'??=")
 "??=": a ??= b means a = a ?? b
 
static readonly Symbol MulAssign = GSymbol.Get("'*=")
 "*=" multiply-and-set operator
 
static readonly Symbol DivAssign = GSymbol.Get("'/=")
 "/=" divide-and-set operator
 
static readonly Symbol ModAssign = GSymbol.Get("'%=")
 "%=" set-to-remainder operator
 
static readonly Symbol SubAssign = GSymbol.Get("'-=")
 "-=" subtract-and-set operator
 
static readonly Symbol AddAssign = GSymbol.Get("'+=")
 "+=" add-and-set operator
 
static readonly Symbol ConcatAssign = GSymbol.Get("'~=")
 "~=" concatenate-and-set operator
 
static readonly Symbol ShrAssign = GSymbol.Get("'>>=")
 ">>=" shift-right-by operator
 
static readonly Symbol ShlAssign = GSymbol.Get("'<<=")
 "<<=" shift-left-by operator
 
static readonly Symbol ExpAssign = GSymbol.Get("'**=")
 "**=" raise-to-exponent-and-set operator
 
static readonly Symbol XorBitsAssign = GSymbol.Get("'^=")
 "^=" bitwise-xor-by operator
 
static readonly Symbol AndBitsAssign = GSymbol.Get("'&=")
 "&=" bitwise-and-with operator
 
static readonly Symbol OrBitsAssign = GSymbol.Get("'|=")
 "|=" set-bits operator
 
static readonly Symbol If = GSymbol.Get("#if")
 e.g. #if(c,x,y) and #if(c,x); I wanted it to be the conditional operator too, but the semantics are a bit different
 
static readonly Symbol DoWhile = GSymbol.Get("#doWhile")
 e.g. #doWhile(x++, condition); <=> do x++; while(condition);
 
static readonly Symbol While = GSymbol.Get("#while")
 e.g. #while(condition,{...}); <=> while(condition) {...}
 
static readonly Symbol UsingStmt = GSymbol.Get("#using")
 e.g. #using(expr, {...}); <=> using(expr) {...} (note: use #import or CodeSymbols.Import for a using directive)
 
static readonly Symbol For = GSymbol.Get("#for")
 e.g. #for(int i = 0, i < Count, i++, {...}); <=> for(int i = 0; i < Count; i++) {...}
 
static readonly Symbol ForEach = GSymbol.Get("#foreach")
 e.g. #foreach(#var(@``, n), list, {...}); <=> foreach(var n in list) {...}
 
static readonly Symbol Label = GSymbol.Get("#label")
 e.g. #label(success) <=> success:
 
static readonly Symbol Case = GSymbol.Get("#case")
 e.g. #case(10, 20) <=> case 10, 20:
 
static readonly Symbol Return = GSymbol.Get("#return")
 e.g. #return(x); <=> return x; [#yield] #return(x) <=> yield return x;
 
static readonly Symbol Continue = GSymbol.Get("#continue")
 e.g. #continue(); <=> continue;
 
static readonly Symbol Break = GSymbol.Get("#break")
 e.g. #break(); <=> break;
 
static readonly Symbol Goto = GSymbol.Get("#goto")
 e.g. #goto(label) <=> goto label;
 
static readonly Symbol GotoCase = GSymbol.Get("#gotoCase")
 e.g. #gotoCase(expr) <=> goto case expr;
 
static readonly Symbol Throw = GSymbol.Get("#throw")
 e.g. #throw(expr); <=> throw expr;
 
static readonly Symbol Checked = GSymbol.Get("#checked")
 e.g. #checked({ stmt; }); <=> checked { stmt; }
 
static readonly Symbol Unchecked = GSymbol.Get("#unchecked")
 e.g. #unchecked({ stmt; }); <=> unchecked { stmt; }
 
static readonly Symbol Fixed = GSymbol.Get("#fixed")
 e.g. #fixed(#var(<tt>*(#int32), x = &y), stmt); <=> fixed(int* x = &y) stmt;
 
static readonly Symbol Lock = GSymbol.Get("#lock")
 e.g. #lock(obj, stmt); <=> lock(obj) stmt;
 
static readonly Symbol Switch = GSymbol.Get("#switch")
 e.g. #switch(n, { ... }); <=> switch(n) { ... }
 
static readonly Symbol Try = GSymbol.Get("#try")
 e.g. #try({...}, #catch(<tt>, @, {...})); <=> try {...} catch {...}
 
static readonly Symbol Catch = GSymbol.Get("#catch")
 "#catch" catch clause of #try statement: #catch(#var(Exception,e), whenExpr, {...})
 
static readonly Symbol Finally = GSymbol.Get("#finally")
 "#finally" finally clause of #try statement: #finally({...})
 
static readonly Symbol Class = GSymbol.Get("#class")
 e.g. #class(Foo, #(IFoo), { }); <=> class Foo : IFoo { }
 
static readonly Symbol Struct = GSymbol.Get("#struct")
 e.g. #struct(Foo, #(IFoo), { }); <=> struct Foo : IFoo { }
 
static readonly Symbol Trait = GSymbol.Get("#trait")
 e.g. #trait(Foo, #(IFoo), { }); <=> trait Foo : IFoo { }
 
static readonly Symbol Enum = GSymbol.Get("#enum")
 e.g. #enum(Foo, #(byte), { }); <=> enum Foo : byte { }
 
static readonly Symbol Alias = GSymbol.Get("#alias")
 
static readonly Symbol Interface = GSymbol.Get("#interface")
 e.g. #interface(IB, #(IA), { }); <=> interface IB : IA { }
 
static readonly Symbol Namespace = GSymbol.Get("#namespace")
 e.g. #namespace(NS, @``, { }); <=> namespace NS { }
 
static readonly Symbol Var = GSymbol.Get("#var")
 e.g. #var(#int32, x = 0, y = 1, z); #var(@``, x = 0) <=> var x = 0;
 
static readonly Symbol Event = GSymbol.Get("#event")
 e.g. #event(EventHandler, Click, { }) <=> event EventHandler Click { }
 
static readonly Symbol Delegate = GSymbol.Get("#delegate")
 e.g. #delegate(#int32, Foo, #tuple()); <=> delegate int Foo();
 
static readonly Symbol Property = GSymbol.Get("#property")
 e.g. #property(#int32, Foo, @``, { get; }) <=> int Foo { get; }
 
static readonly Symbol Where = GSymbol.Get("#where")
 "#where" e.g. class Foo<T> where T:class, Foo {} <=> #class(#of(Foo, [#where(#class, Foo)] T), #(), {});
 
static readonly Symbol This = GSymbol.Get("#this")
 "#this" e.g. this.X <=> #this.X; this(arg) <=> #this(arg).
 
static readonly Symbol Base = GSymbol.Get("#base")
 "#base" e.g. base.X <=> #base.X; base(arg) <=> #base(arg).
 
static readonly Symbol Operator = GSymbol.Get("#operator")
 e.g. #fn(#bool, [#operator] <tt>==, #(Foo a, Foo b))
 
static readonly Symbol Implicit = GSymbol.Get("#implicit")
 e.g. [#implicit] #fn(#int32, [#operator] #cast, (Foo a,))
 
static readonly Symbol Explicit = GSymbol.Get("#explicit")
 e.g. [#explicit] #fn(#int32, [#operator] #cast, (Foo a,))
 
static readonly Symbol Missing = GSymbol.Empty
 Indicates that a syntax element was omitted, e.g. Foo(, y) => Foo(@``, y)
 
static readonly Symbol Splice = GSymbol.Get("#splice")
 When a macro returns #splice(a, b, c), the argument list (a, b, c) is spliced into the surrounding code.
 
static readonly Symbol Assembly = GSymbol.Get("#assembly")
 e.g. [assembly: Foo] <=> #assembly(Foo);
 
static readonly Symbol Module = GSymbol.Get("#module")
 e.g. [module: Foo] <=> [Foo] #module;
 
static readonly Symbol Import = GSymbol.Get("#import")
 #import is used instead of #using because the using(...) {...} statement already uses #using More...
 
static readonly Symbol Partial = GSymbol.Get("#partial")
 
static readonly Symbol Yield = GSymbol.Get("#yield")
 e.g. #return(x); <=> return x; [#yield] #return(x) <=> yield return x;
 
static readonly Symbol ArrayInit = GSymbol.Get("#arrayInit")
 C# e.g. int[] x = {1,2} <=> int[] x = #arrayInit(1, 2)
 
static readonly Symbol StackAlloc = GSymbol.Get("#stackalloc")
 #stackalloc for C# stackalloc (TODO)
 

Member Data Documentation

readonly Symbol Loyc.Syntax.CodeSymbols.Alias = GSymbol.Get("#alias")
static

e.g. #alias(Int = int, #(IMath), { }); <=> alias Int = int : IMath { } also, [#filePrivate] #alias(I = System.Int32) <=> using I = System.Int32;

readonly Symbol Loyc.Syntax.CodeSymbols.AltList = GSymbol.Get("#")
static

# is used for lists of things in definition constructs, e.g. #class(Derived, #(Base, IEnumerable), {...}). For a time, #tuple was used for this purpose; the problem is that a find-and-replace operation intended to find run-time tuples could accidentally match one of these lists. So I decided to dedicate # for use inside special constructs; its meaning depends on context.

readonly Symbol Loyc.Syntax.CodeSymbols.Import = GSymbol.Get("#import")
static

#import is used instead of #using because the using(...) {...} statement already uses #using

e.g. using System; <=> #import(System);

readonly Symbol Loyc.Syntax.CodeSymbols.IndexBracks = GSymbol.Get("'_[]")
static

foo[1, A] <=> <tt>_[](foo, 1, A), but in a type context, Foo[] <=> #of(<tt>[], Foo)

"_[]" indexing operator

readonly Symbol Loyc.Syntax.CodeSymbols.NullIndexBracks = GSymbol.Get("'?[]")
static

<tt>?[](foo, #(1, A)) <=> foo?[1, A] (TENTATIVE, may be changed later)

"?[]" indexing operator of C# 6

readonly Symbol Loyc.Syntax.CodeSymbols.Typeof = GSymbol.Get("#typeof")
static

"#typeof" typeof(Foo) <=> #typeof(Foo), typeof<foo> <=> #of(#typeof, foo)