private ConnectToPropertyChanged ( property : string, dataContext : object ) : void
    {
      def propertyChanged = dataContext : INotifyPropertyChanged;
    }

expected System.ComponentModel.INotifyPropertyChanged, got object in type-enforced expression: System.Object is not a subtype of System.ComponentModel.INotifyPropertyChanged [simple require]

def propertyChanged = match (dataContext) { | x is INotifyPropertyChanged => x; | _ => null }

def propertyChanged = match(dataContext)
{
  | x is INotifyPropertyChanged => x
  | _ => null
}

    
V>    private ConnectToPropertyChanged ( property : string, dataContext : object ) : void
V>    {
V>      def propertyChanged = dataContext : INotifyPropertyChanged;
V>    }

V>

private ConnectToPropertyChanged ( property : string, dataContext : object ) : void
{
  match(dataContext)
  {
    | x is INotifyPropertyChanged =>
      x.PropetyChanged += (_, e) =>
      {
         when(e.PropertyName == property)
         {
           ...
         }
      }
    | _ => () // ничего не делаем
  }
}

      def propertyChanged = dataContext : INotifyPropertyChanged;
      when ( propertyChanged != null )
        propertyChanged.PropertyChanged += ( s, e ) => when ( e.PropertyName == property ) PropertyChanged ( s, e.PropertyName );

      try
      {
         def propertyChanged = dataContext :> INotifyPropertyChanged;
         propertyChanged.PropertyChanged += ( s, e ) => when ( e.PropertyName == property ) PropertyChanged ( s, e.PropertyName );
      }
      catch ( e : InvalidCastException )
      {

      }

V>      def propertyChanged = dataContext : INotifyPropertyChanged;
V>      when ( propertyChanged != null )
V>        propertyChanged.PropertyChanged += ( s, e ) => when ( e.PropertyName == property ) PropertyChanged ( s, e.PropertyName );
V>

match (dataContext)
{
  | propertyChanged is INotifyPropertyChanged => 
    propertyChanged.PropertyChanged += ( s, e ) => when ( e.PropertyName == property ) PropertyChanged ( s, e.PropertyName );

  | _ => ()
}

matched for 3819
ased for    3530

  public class Class1 : ITester
  {
    public Test(lst : array[CommonClasses.Base]) : void
    {
      foreach (b in lst)
      {
        | b is D1=> b.d1()
        | b is D2=> b.d2()
      }
    } 
  }

    public class Class1 : ITester
    {
        public void Test(Base[] lst)
        {
            foreach (var b in lst)
            {
                var d1 = b as D1;
                if (d1 != null)
                {
                    d1.d1();
                    continue;
                }
                var d2 = b as D2;
                if (d2 != null)
                    d2.d2();
            }
        }
    }
//------------------------
    public interface ITester
    {
        void Test(Base[] lst);
    }

    public abstract class Base { }
    public class D1 : Base 
    {
        public void d1() { }
    }
    public class D2 : Base
    {
        public void d2() { }
    }

BM>matched for 3819
BM>ased for    3530
BM>

    def o = "test" : object;
    match (o)
    {
      | x is string =>  WriteLine(x)
      | _ => ()
    }

    object o = "test";
    if (o is string)
    {
        string x = (string) o;
        Console.WriteLine(x);
    }

int a = 6;
var enumerable = lst.Where(i => i > a);
a = 500;
var arr = enumerable.ToArray();

  .locals init (
        [0] class [CommonClasses]CommonClasses.Base b,
        [1] class [CommonClasses]CommonClasses.D1 d1)
ldloc.0
stloc.1  //СОбсвнноэтои весь каст

//теперь можно вызвать метод
    L_0021: ldloc.1 
    L_0022: callvirt instance void [CommonClasses]CommonClasses.D1::d1()

// собственно можно было загрузить нулевой и вызвать метод, но такая наглость уже может не понравиться JITC'y