having ?

L>    def props =
L>                {
L>                    MouseMove += handler;
L>                    Click => form.Text = "Click!"; // упрощенная форма, как в компиляторе Mono C#
L>                }

L>    def btn = Button() with props
L>

    expr props =
               {
                    MouseMove += handler;
                    Click => form.Text = "Click!"; // упрощенная форма, как в компиляторе Mono C#
               }
    def btn = Button() with props

      mutable txtBox;
      mutable lbl;
      
      def _w = Window() <-
      {
        Width = 200;
        Height = 100;
        Content = StackPanel() <-
        {
          Children <-
          [
            txtBox <- TextBox() <- { Text = "Some text"},
            Button() <- 
            {
              Content = "Copy";
              Click += (_) => { lbl.Content = txtBox.Text }
            },
            lbl <- Label()
          ]
        }
      }
      
      _ = _w.ShowDialog();

нужные контрольчики лежат в переменных

Ну мешать эту макру с "<-" не обязательно, просто этот символ для этого действия ажеться логичным(и другого не придумал) а оператор "=" как ихвестно имеет тип возврата void по этому надо как то выкручиваться

Желаю услышать ваши мнения. Если катит то доведу до ума и закомичу ибо ИМХО полезная доработка для этого макроса.

mutable pnl : StackPanel;
mutable txtBox : TextBox;

def w = Window() <-
{
    Content = pnl <-
    {
        Children <-
        [
             txtBox <- { blah blah }
        ]
    }
}

def w = Window() <-
{
    Content = StackPanel() as pnl <-
    {
        Children <-
        [
             TextBox() as this.txtBox <- { blah blah } // если написано this, то генерируется член класса, а не локальная переменная
        ]
    }
}

C>def w = Window() <-
C>{
C>    Content = StackPanel() as pnl <-
C>    {
C>        Children <-
C>        [
C>             TextBox() as this.txtBox <- { blah blah } // если написано this, то генерируется член класса, а не локальная переменная
C>        ]
C>    }
C>}
C>

def x = Node() as n <-
{
  Parent = n
};

  public macro Macro2()
  {
    <[
      def var = 8
    ]>;
  }

   Main() : void
    {
      Macro2();      
      def a = var;
    }

Main.n:26:15:26:18: ←[01;31merror←[0m: unbound name `var'

C>mutable pnl : StackPanel;
C>mutable txtBox : TextBox;
C>def w = Window() <-
C>{
C>    Content = StackPanel() as pnl <-
C>    {
C>        Children <-
C>        [
C>             TextBox() as this.txtBox <- { blah blah } // если написано this, то генерируется член класса, а не локальная переменная
C>        ]
C>    }
C>}
C>

mutable label = Label();
Window() <-{ Contetn = label <- {....} }

def x = X() as current <-
{
   // используем current для создания циклических структур данных
}

mutable obj;

def x = X() <- 
{
  Y = Y() as out obj <-
  {
    A = ... // используем инициализированный obj здесь 
    B = ...
  }
}

// а также уже после блока

H>mutable obj;

H>def x = X() <- 
H>{
H>  Y = Y() as out obj <-
H>  {
H>    A = ... // используем инициализированный obj здесь 
H>    B = ...
H>  }
H>}

H>// а также уже после блока
H>

mutable obj;

def x = X() <- 
{
  Y = out Y() as obj <-
  {
    A = ... // используем инициализированный obj здесь 
    B = ...
  }
}

// а также уже после блока

H>def x = X() as current <-
H>{
H>   // используем current для создания циклических структур данных
H>}
H>

  public macro @as(obj, ing, initializer) // пробовал public macro @<-(obj, ing, initializer) как было в оригинале, не помогло..
  syntax( obj, "as", ing, "<-", initializer)
  {    
    WithMacroImpl.Run(obj, initializer);
  }

def _w = Window() as temp <-  {}

    public Run(obj : PExpr, initializer : PExpr) : PExpr
    {
      def (name, assignment) =
        match (obj)
        {
          | <[ $obj in $inn ]> when inn is PExpr.Ref => (inn, <[ $inn = $obj;]>)
          | _                  => 
            def name = <[ $(Macros.NewSymbol("initializedObject") : name) ]>;
            (name, <[def $name = $obj;]>)
        }   
      def statements = MakeStatements(initializer, name);
      ;
        
      <[
        $(assignment);
        $(statements);
        $(name)
      ]>
    }

BM>  public macro @as(obj, ing, initializer) // пробовал public macro @<-(obj, ing, initializer) как было в оригинале, не помогло..
BM>  syntax( obj, "as", ing, "<-", initializer)
BM>  {    
BM>    WithMacroImpl.Run(obj, initializer);
BM>  }
BM>

match(obj)
{
  | <[ $ctor as $(var : name) ]>     => случай_1
  | <[ out $ctor as $(var : name) ]> => случай_2
}

H>>match(obj)
H>>{
H>>  | <[ $ctor as $(var : name) ]>     => случай_1
H>>  | <[ out $ctor as $(var : name) ]> => случай_2
H>>}
H>>

  /// syntax is <[ obj <- { Foo = bar; ... } ]>
  /// or <[ obj <- ( Foo = bar, ... ) ]>
  /// or <[ obj <- [ foo, bar, ... ] ]>
  public macro @<-(obj, initializer)
  {
    def obj = match(obj)
    {
      | <[ $obj as $(n : name) ]> => 
        match(Macros.ImplicitCTX().LocalContext.FindLocal(n))
        {
          | Some(localValue) when localValue.IsMutable =>
            Message.Hint(n.Location, $"case2, mutable variable name detected: $n");

          | _ =>
            Message.Hint(n.Location, $"case1, variable name detected: $n");
        }
        obj

      | <[ $obj as $n ]> => 
        Message.Error(n.Location, $"variable name expected, but `$n' found");
        obj
        
      | _ => obj
    }

    WithMacroImpl.Run(obj, initializer);
  }