mutable x : void = ();
  x = WriteLine("Hi");

  //Выполнение кода в каком-то контексте
  ExecInContext[T](f : SomeContext -> T) : T
  {
    using(def ctx = SomeContext())
      f(ctx);
  }

  //Так, с копипастом
  ExecInContext(f : SomeContext -> void) : void
  {
    using(def ctx = SomeContext())
      f(ctx);
  }

  //Или как-нибудь так
  ExecInContext(f : SomeContext -> void) : void
  {
    _ = ExecInContext(ctx => { f(ctx); null : object; });
  }

public struct VoidStruct
{
  public static Value : VoidStruct = VoidStruct();
}

ExecInContext(_ => {/*...*/});//если тело лямбды имеет тип void
ExecInContext.[VoidStruct](_ => {/*...*/; VoidStruct.Value; });//заменять так

public abstract class VoidClass
{
  public static Value : VoidClass = null;
  private this() {}
}

ExecInContext_Class[T](f : SomeContext -> T) : T
      where T : class
{
  using(def ctx = SomeContext())
    f(ctx);
}

ExecInContext_Class(_ => {/*...*/});//если тело лямбды имеет тип void
ExecInContext_Class.[VoidClass](_ => {/*...*/; VoidClass.Value;});//заменять так

module Test
{
  F(ctx : SomeContext) : void { /*...*/ }
}

ExecInContext(F);
//придется заменять на
ExecInContext(ctx => {F(ctx); VoidStruct.Value; });

def f : SomeContext->void = ctx => {/*...*/};
//тут какой-то код, для которого требуется, чтобы f была с типом SomeContext->void
ExecInContext(f);//тоже придется оборачивать

[AddVoidOverload]
ExecInContext[T](f : SomeContext -> T) : T
{
  using(def ctx = SomeContext())
    f(ctx);
}

ExecInContext(f : SomeContext -> void) : void
{
  using(def ctx = SomeContext())
    f(ctx);
}

__>[AddVoidOverload]
__>ExecInContext[T](f : SomeContext -> T) : T
__>{
__>  using(def ctx = SomeContext())
__>    f(ctx);
__>}
__>

__>ExecInContext(f : SomeContext -> void) : void
__>{
__>  using(def ctx = SomeContext())
__>    f(ctx);
__>}
__>

[AddVoidOverload]
F[T1, T2]():void{}

  ExecInContext(f : SomeContext -> void) : void
  {
    _ = ExecInContext(ctx => { f(ctx); null : object; });
  }

  public static @: (f : FunctionVoid['p1]) : 'p1 -> System.Reflection.Missing
  {
      p1 => {f.apply_void(p1); System.Reflection.Missing.Value;}
  }

  Exec[T](f : object -> T) : T
  {
      f(null);
  }

  _ = Exec(_=>{});