<div dir="ltr"><div class="gmail_extra"><div class="gmail_quote">2013/10/31 Sven Barth <span dir="ltr"><<a href="mailto:pascaldragon@googlemail.com" target="_blank">pascaldragon@googlemail.com</a>></span><br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">


  
    
  
  <div text="#000000" bgcolor="#FFFFFF">
    <div>Am 31.10.2013 02:45, schrieb Xiangrong
      Fang:<br>
    </div><div><div class="h5">
    <blockquote type="cite">
      <div dir="ltr">
        <div style="font-family:courier new,monospace"><span style="font-family:arial">2013/10/30
            Jonas Maebe </span><span dir="ltr" style="font-family:arial"><<a href="mailto:jonas.maebe@elis.ugent.be" target="_blank">jonas.maebe@elis.ugent.be</a>></span><br>
        </div>
        <div class="gmail_extra">
          <div class="gmail_quote">
            <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
              <div><br>
              </div>
              This is not equivalent. A private type declaration in a
              class adds a new identifier that is visible inside that
              class. You then use it, still in that class, to declare
              the return type of a function. Next, in a scope where that
              type identifier is no longer visible, you call the
              function.<br>
              <br>
              My example is a complete match to that scenario as far as
              identifier visibility is concerned (you use a type in a
              scope where it is visible to declare a function return
              type, and then call the function in a scope where it is
              not visible). In your example, the type is not visible in
              the place where the function is declared but only where it
              is defined
              <div>
                .</div>
            </blockquote>
            <div><br>
            </div>
            <div>
              <div>This is logically WRONG. Because to the
                machine, any function return value can be seen as an
                array of bytes, for example, a pointer is array[0..3] of
                Byte on a 32-bit machine.  The purpose of type system is
                to explain what these bytes stands for. So, if a type is
                out-of-scope, how do you interpret the data?  </div>
              <div><br>
              </div>
              <div>The current "delphi compatible"
                implementation IS using the type information to compile
                the program, i.e. although it is not visible, it is
                indeed used by the compile, which, in my opinion,
                violates visibility rules.</div>
              <div><br>
              </div>
              <div>Standing on your view point, if a type
                is no longer visible, but a variable (function return
                value) of that type is in current scope, and understood
                by the program, this means, this value itself carries
                type information!  Is is kind of meta data available in
                Pascal? If so, I think RTTI should work for ANY kind of
                primitive data types.</div>
              <br>
            </div>
          </div>
        </div>
      </div>
    </blockquote></div></div>
    For unit interfaces there is indeed the point that if unit A uses
    unit B then the program which uses unit A will be able to access
    types used by unit A. E.g.:<br>
    <br>
    === unit A ===<br>
    <br>
    unit A;<br>
    <br>
    interface<br>
    <br>
    type<br>
      TTest = class<br>
        procedure Test;<br>
      end;<br>
    <br>
    implementation<br>
    <br>
    procedure TTest.Test;<br>
    begin<br>
      Writeln('Foobar');<br>
    end;<br>
    <br>
    end.<br>
    <br>
    === unit A ===<br>
    <br>
    === unit B ===<br>
    <br>
    unit B;<br>
    <br>
    interface<br>
    <br>
    uses<br>
      A;<br>
    <br>
    function SomeTest: TTest;<br>
    <br>
    implementation<br>
    <br>
    function SomeTest: TTest;<br>
    begin<br>
      Result := TTest.Create;<br>
    end;<br>
    <br>
    end.<br>
    <br>
    === unit B ===<br>
    <br>
    === program ===<br>
    <br>
    program test;<br>
    <br>
    uses<br>
      B;<br>
    <br>
    begin<br>
      // there won't be an error here<br>
      SomeTest.Test;<br>
    end.<br>
    <br>
    === program ===<br>
    <br>
    It's this way at least since Turbo Pascal (though without classes
    then ;) ).<br>
  </div>

</blockquote></div><br></div><div class="gmail_extra">Yes, I agree this is the TP/Delphi way, and as such should be kept at least in DELPHI mode. But is this really good? Doesn't this contradict the Pascal philosophy? Borland did a few questionable things (look at how you used the semicolons in you examples above ;-) ), and it took some decisions when implementing units. But how is this handled in Modula?<br clear="all">

</div><div class="gmail_extra"><br>-- <br>Frederic Da Vitoria<br>(davitof)<br><br>Membre de l'April - « promouvoir et défendre le logiciel libre » - <a href="http://www.april.org" target="_blank">http://www.april.org</a><br>


</div></div>