Return to localspec CVS log

Up to [Research Unix] / researchv10no / cmd / sml / doc

Annotation of researchv10no/cmd/sml/doc/localspec, revision 1.1.1.1

1.1       root        1:        What are the meaning of "local" and "open" in signatures?
                      2: 
                      3:                        David B. MacQueen
                      4: 
                      5: I am not sure what the purpose of the local spec form was supposed to be.
                      6: Specifications such as 
                      7: 
                      8:    local val x : t
                      9:     in val y : s
                     10:    end
                     11: 
                     12: are certainly useless, and
                     13: 
                     14:    local type t
                     15:     in val x : t
                     16:    end
                     17: 
                     18: does not seem very interesting either.  Presumably the purpose of local specs
                     19: was to localize the scope of open specs, as in
                     20: 
                     21:    structure A : sig type t ... end
                     22:    local open A
                     23:     in val x : t
                     24:    end
                     25: 
                     26: But I would argue that open specs are really just an abbreviation device and
                     27: do not add specifications to a signature in any case.  The bindings in a
                     28: structure, such as A above, are a different kind of entity from normal
                     29: signature specifications, and they can be treated differently from
                     30: specifications.  It makes sense to include the specifications in a signature
                     31: in another signature, as is done by the include spec, but it does not make
                     32: sense to include the components of a structure in a signature.  For instance,
                     33: consider the following example:
                     34: 
                     35:    structure A = struct type t = int val x = 3 end
                     36:    signature SIG =
                     37:    sig
                     38:      open A
                     39:    end
                     40: 
                     41: What is the meaning of SIG?  Since the unconstrained structure A matches
                     42: many different signatures, it would seem that SIG is not well defined.
                     43: 
                     44: As we have implemented the open specification, it simply makes
                     45: the identifiers inside the opened structures visible in unqualified form, so
                     46: that "t" can be used as an abbreviation for "A.t" in the above example.  The
                     47: scope of the open specification is by default the remainder of the signature
                     48: expression, and an open specification does not add any new components to a
                     49: signature.  Thus the above definition of SIG is equivalent to
                     50: 
                     51:    signature SIG = sig end
                     52: 
                     53: This view of open specs seems to eliminate any justification for local
                     54: specs, so they are suppored only in a dummy form for compatibility.  The 
                     55: meaning of
                     56: 
                     57:    local spec1 in spec2 end
                     58: 
                     59: is the same as
                     60: 
                     61:    spec1 spec2
                     62: 
                     63: except that the specifications in spec1 are ignored during signature
                     64: matching.  If spec1 is an open spec, which is the only reasonable
                     65: possibility, the open spec remains in force even after the end of the local
                     66: spec.  For instance,
                     67: 
                     68:   sig
                     69:    structure A : sig type t ... end
                     70:    type t
                     71:    local open A in
                     72:     in val x : t  (* t is A.t *)
                     73:    end
                     74:    val y : t  (* t is still A.t, not the top level t *)
                     75:   end
                     76: 
                     77: We would be interested to hear any arguments against this treatment.  If it
                     78: is generally accepted, it would seem to make sense to delete local specs from
                     79: the language.  In any case, it should be considered a dubious feature to be
                     80: used only when necessary for compatibility.  I also consider the let
                     81: structure expression a dubious feature, but it is at least fairly simple to
                     82: implement.  

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.