title: What would be a proper naming convention when hiding dependencies behind a facade?
body: <p>I've got a class performing some operation, say parsing and it's going to be a public repository. Because there is some complexity to the constructor and it is not important for the end user, I wanted to hide it behind a facade.</p>
  
  <pre><code>// interface
  interface ParserInterface {
      function parse(string $input): Document;
  }
  
  // implementation
  class ParserImplementation implements ParserInterface {
      function __construct(
          Normalizer $normalizer,
          Tokenizer $tokenizer,
          Interpreter $interpreter,
          etc.
      ) {
          $this-&gt;normalizer = $normalizer;
          $this-&gt;tokenizer = $tokenizer;
          $this-&gt;interpreter = $interpreter;
      }
  
      function parse(string $input): Document {
          $normalizedInput = $this-&gt;normalizer-&gt;normalize($input);
          $tokens = $this-&gt;tokenizer-&gt;tokenize($normalizedInput);
          return $this-&gt;interpreter-&gt;interpret($tokens);
      }
  }
  
  // facade
  class ParserFacade implements ParserInterface {
      private $parser;
  
      function __construct() {
          $this-&gt;parser = new ParserImplementation(
              new Normalizer(),
              new Tokenizer(),
              etc.
          );
      }
  
      function parse(string $input) {
          return $this-&gt;parser-&gt;parse($input);
      }
  }
  </code></pre>
  
  <p>As you see, there is also an interface there.</p>
  
  <p>Now, for the outside application it is the facade that is the parser. For the co-dependent code, it is the interface that is the parser. And for me developing the above solution, it is the ParserImplementation that is the real parser i.e. it is it that encompasses the whole parsing logic. So now, I'm completely lost as to the proper naming convention.</p>
  
  <p>I'd prefer to name the interface as just Parser and the fasade as something a little stating my intention: CustomParser because the whole is a custom implementation of something that has some standard implementation. But then I can't find a pattern to name the inside class (ParserImplementation in the code above).</p>
  
  <p>Is there a well established practice in that regard?</p>