module A{
  export all reveals *
  export provides P // I don't want to reveal the implementation of P by default
  type P<!T(==)> = iset<T>
}
module B{
  import opened A`all
  export provides Test
  function Test(): P<nat>
}

module A{
  export all
    reveals *
  export
    provides P // I don't want to reveal the implementation of P by default
  type P<!T(==)> = iset<T>
}
module B {
  export
    provides Test, JustP
  import JustP = A
  import opened Everything = A`all
  function Test(): P<nat> {
    iset{} // module B knows what P is, because it imports A`all
  }
}
module Client {
  import B
  method M() {
    var p: B.JustP.P<nat>; // Client can use P, but only as an opaque type
    p := iset{}; // error: Client does not know what P is
  }
}

  import opened Everything = A`all

  import Everything = A`all

function Test(): Everything.P<nat>

  import opened A`all