class A ['a] where 'a : class {
  public foo (_ : 'a) : 'a {
    null
  }
}

class B ['a] where 'a : struct {
  public foo (_ : 'a) : 'a {
    'a ()
  }
}

class C ['a] where 'a : new () {
  public foo (_ : 'a) : 'a {
    'a ()
  }
}

class D ['a] where 'a : class, new () {
  public foo (_ : 'a) : 'a {
    assert (null != 'a ());
    'a ()
  }
}

namespace EnumSpecifier {
       enum LicenseAccessLevelType
       {
               | Growing
               | Supplemental
       }

       [Record]
       class LicenseManager['t] where 't : enum
       {
               _current : 't;
               _licenseAccessLevelType : LicenseAccessLevelType = LicenseAccessLevelType.Growing;

               public Validate(required : 't) : bool
               {
                       def curInt = (_current:System.IConvertible).ToInt32(null);
                       def reqInt = (required:System.IConvertible).ToInt32(null);

                       match(_licenseAccessLevelType)
                       {
                          | Growing =>
                               (curInt < reqInt);
                          | Supplemental =>
                               (curInt & reqInt) != curInt;
                          | _ =>
                               throw System.NotImplementedException();
                       }
               }
       }
       class E { 
         public static Run () : void { 
           def l = LicenseManager (LicenseAccessLevelType.Growing, LicenseAccessLevelType.Growing);  
           _ = l.Validate (LicenseAccessLevelType.Growing);
         }  
       }     
}  

class Foo {
}

class A' ['a] where 'a : class
{
  f : A ['a];
}

class B' ['a] where 'a : struct
{
  f : B ['a];
}

class C' ['a] where 'a : new ()
{
  f : C ['a];
}

assert (A().foo ("a") == null);
assert (B().foo (0) == 0);
assert (C().foo (2) == 0);
assert (C().foo (Foo()) != null);
assert (D().foo (Foo()) != null);
EnumSpecifier.E.Run ();


/*
BEGIN-OUTPUT
END-OUTPUT
*/