• 0 Posts
  • 12 Comments
Joined 8 months ago
cake
Cake day: March 22nd, 2024

help-circle



  • How things work in BC:

    When a practitioner changes for a service, they can’t bill any more than what the Payment Schedule says that procedure costs. So if the Medical Services Plan isn’t being billed (eg the doctor or patient opted out of MSP, the patient is a non-resident, the service is in the Payment Schedule but the Payment Schedule requirements consider it unnecessary) or MSP isn’t covering the full cost (some stuff like a second or third biopsy will only be covered 50 %), then the doctor can’t bill the patient any more than they would’ve billed MSP. This means practitioners have no incentive to not bill MSP.

    The Payment Schedule (and thus allocation of the MSP budget) is set out by the Medical Services Commission which is composed of three representatives from the government, three from the Doctors of BC (the professional association which promotes the interests of member doctors) and three members of the public. So even if the government pushes for more stringent coverage requirements and budget surplus, the doctors are there to push for higher fees and less billing paperwork (besides exceptional circumstances like out-of-country care, patients can’t submit claims directly; everything is on the practitioner’s end), and the public is there to push for more coverage.

    In practice this means that for the vast vast majority of services, the only justification that the practitioner needs to give MSP for coverage is the International Classification of Diseases diagnostic code for the condition being treated.






  • You already can do that with C++20 concepts and the requires expression

    template <typename T>
    concept has_member_foo = requires(T t) {
        t.foo();
    };
    
    // Will fail to instantiate (with nice error 
    // message) if t.foo() is ill-formed
    template <has_member_foo T>
    void bar(T t) {
        // ...
    }
    
    // abbreviated form of above
    void baz(has_member_foo auto t) {
        // ...
    }
    
    // verbose form of above
    template <typename T> requires
        has_member_foo<T>
    void biz(T t) {
        // ...
    }
    
    // same as above but with anonymous concept
    template <typename T> requires
        requires(T t) { t.foo(); }
    void bom(T t) {
        // ...
    }
    
    // If already inside a function
    if constexpr (has_member_foo<T>) {
        // ...
    }
    
    // Same but with anonymous concept
    if constexpr (requires(T t) { t.foo(); }) {
        // ...
    }