C#.NStar

for (i in collection)
{
    ...
}

for (i in a..b)
{
    ...
}

const [typename T, (Class)] ClassName = new(
{
    ...
});

const ClassName = new [typename T, (Class)](
{
    ...
});

const var ClassName = new [typename T, (Class)](
{
    ...
});

const [typename T, (Class)] ClassName = new [typename T, (Class)](
{
    ...
});

const [typename T : BaseType, (Class : BaseType2)] ClassName = new(
{
    ...
});

const ClassName = new [typename T : BaseType, (Class : BaseType2)](
{
    ...
});

const var ClassName = new [typename T : BaseType, (Class : BaseType2)](
{
    ...
});

const [typename T : BaseType, (Class : BaseType2)] ClassName = new [typename T : BaseType, (Class : BaseType2)](
{
    ...
});

try
{
    ...
}
catch (ExceptionType var) if (condition) // if, а не when
{
    ...
}

using System;
using System.Threading;
Class MyClass
{
    Constructor()
    {
    }
    int Function Sync()
    {
        var x = MyClass2.MyFunc(5);
        return x;
    }
    Task[int] Function Async1()
    {
        var x = MyClass2.MyFunc(5);
        return x;
    }
    Task[int] Function Async2(int n)
    {
        return n * n;
    }
}
 
static Class MyClass2
{
    Func[Task[int], int] MyFunc = new MyClass().Async2;
}
 
return new MyClass().Async1();

object item = "Welcome!";
if (item is string text)
    return text;

abstract Class BaseStack
{
    required typename T { get, init };
    
    abstract T Function Peek();
    abstract T Function Pop();
    abstract null Function Push(T item);
}
 
const [typename T, (Class : BaseStack[T])] Stack = new(
{
    private () T list = new(32);
 
    T Function Peek()
    {
        return list[^1];
    }
 
    T Function Pop
    {
        return list.GetAndRemove(list.Length - 1);
    }
 
    null Function Push(T item)
    {
        list.Add(item);
    }
});
 
BaseStack[int] intStack = new Stack[int]();
intStack.Push(5);
intStack.Push(10);
var x = (intStack.Pop(), intStack.Peek());
BaseStack[string] stringStack = new Stack[string]();
stringStack.Push("A");
stringStack.Push("B");
var y = (stringStack.Pop(), stringStack.Peek());
return (x, y);

() int list = new();
for (i in Chain(0, 10)) while (i * i % 20 < 10)
{
    list.Add(i);
}
return list;

int n = 0;
for (i in 1..1000)
{
    n++;
}
return n;

Record Pair(string Name, int Value);
Pair pair = new("Status", 100);
return pair;

const [typename T : IComparable[T], (Class)] Repository = new(
{
    private () T items = new();
 
    null Function Add(T item)
    {
        items.Add(item);
    }
 
    T Function GetMax()
    {
        if (items.Length == 0)
            return null;
        return Max(items);
    }
});
 
Class Product : IComparable[Product]
{
    int Id;
    int Function CompareTo(Product product)
    {
        return Id.CompareTo(product.Id);
    }
}
 
var repo = new Repository[Product]();
repo.Add(new Product[1]());
repo.Add(new Product[5]());
return repo.GetMax().Id;

using System;
using System.IO;
try
{
    () int list = (1, 2, 3);
    return list.IndexOf(1, 5);
}
catch (ex) if (ex is not ArgumentException)
{
    return 1;
}
catch (ex)
{
    return "" + ex.Message;
}
return 2;

list(3) int a = (((1, 2, 3), (4, 5, 6), (7, 8, 9)), ((10, 11, 12), (13, 14, 15), (16, 17, 18)), ((19, 20, 21), (22, 23, 24), (25, 26, 27)));
return a[1, 2, 3];

Class MyClass
{
   int a = 5;
   real b = 3.14159;
   string c = "A";
 
   Constructor(bool bool)
   {
      if (bool)
      {
         a = 12;
      }
   }
}
MyClass a1 = new MyClass();
MyClass a2 = new MyClass(8, 2.71828, "$");
MyClass a3 = new MyClass(8, 2.71828);
MyClass a4 = new MyClass(true);
return (a1, a2, a3, a4);

real a = 0;
loop
{
   if !(a >= 10)
      a++;
   else if !(a >= 12)
   {
      a += 0.25;
      continue;
   }
   else if !(a > null)
      continue;
   else
   {
      break;
   }
}
return a;

real Function F(real x, real y)
{
   return x * x + x * y + y * y;
}
System.Func[real, real, real] f;
f = F;
real a = f(3.14159, 2.71828);
f = Max;
real b = f(3.14159, 2.71828);
return (a, b);

Namespace MyNamespace
{
  Namespace MyNamespace
  {
    Class MyClass
    {
      int a = 5;
      real b = 3.14159;
      string c = "A";
 
      Constructor(bool bool)
      {
        if (bool)
          a = 12;
      }
    }
  }
}
MyNamespace.MyNamespace.MyClass a1 = new MyNamespace.MyNamespace.MyClass();
MyNamespace.MyNamespace.MyClass a2 = new MyNamespace.MyNamespace.MyClass(8, 2.71828, "$");
MyNamespace.MyNamespace.MyClass a3 = new MyNamespace.MyNamespace.MyClass(8, 2.71828);
MyNamespace.MyNamespace.MyClass a4 = new MyNamespace.MyNamespace.MyClass(true);
return (a1, a2, a3, a4);

(int, int)[2] Function F()
{
  Class MyClass
  {
    int a = 0;
  }
  MyClass b = new MyClass(5);
  return ((b.a, new MyClass(8).a), (b.a, new MyClass(8).a));
}
return F();

return ExecuteString("return args[1];", Q());

System.Func[int] Function F()
{
    int Function F2()
    {
        return 100;
    }
    return F2;
}
return F()();