[<AutoOpen>]

module MBool =

  type True =

    | True 

    interface IBool with

        member this.toBool = UBool.UTrue this 

    interface IBool<True>  with

        member this.toBoolG = this 

    interface ITrue with

        member this.toTrue = this

  and False = 

    | False  

    with

      interface IBool with

        member this.toBool = UBool.UFalse this 

      interface IBool<False> with   

        member this.toBoolG = this 

      interface IFalse with   

        member this.toFalse = this

  and IBool = abstract member toBool: UBool 

  and IBool<'T when 'T :> IBool> = 

    inherit IBool

    abstract member toBoolG: 'T  

  and ITrue = 

    inherit IBool<True>

    abstract member toTrue: True  

  and IFalse = 

    inherit IBool<False> 

    abstract member toFalse: False

  and BoolStatic =

    static member toTrue (_:#ITrue) = True 

    static member toFalse (_: #IFalse) = False 

    static member toBool (_:True) = UBool.UTrue True 

    static member toBool(_:False) = UBool.UFalse False   

    static member inline Not (_:True) = False 

    static member inline Not (_:False) = True

  and UBool = 

    | UTrue of True   

    | UFalse of False  

    with   

      interface IBool with

        member this.toBool = this

      interface IBool<UBool> with

        member this.toBoolG = 

          this

​

module FlagTypes =

  type CCU = CCU

  type JOU = JOU

module Flags =

  [<RequireQualifiedAccess>]

  type Flag<'F> =

    | Flag of 'F * IBool   

    interface IFlag<'F> with 

      member this.toFlag = this   

  and IFlag<'F> =

    abstract member toFlag: Flag<'F>

​

  [<RequireQualifiedAccess>]

  type FlagB<'F, 'B when 'B :> IBool> =

    | Flag of 'F * IBool<'B>

    interface IFlag<'F> with 

      member this.toFlag =

        let Flag (f, b) = this in FlagB.Flag (f, b)

    interface IFlag<'F,'B> with 

      member this.toFlag = this

  and IFlag<'F, 'B when 'B :> IBool> =

    abstract member toFlag: FlagB<'F,'B>

​

  type TrueFlag<'F> = FlagB<'F, True>

  type FalseFlag<'F> = FlagB<'F, False>

  type And<'F1, 'F2> = 

    | And of Flag<'F1>*Flag<'F2>

  type And<'F1,'F2,'B1,'B2 when 'B1 :> IBool and 'B2 :> IBool> =

    | And of FlagB<'F1,'B1> * FlagB<'F2,'B2>