hiding the 'mutable' modifier

hiding the 'mutable' modifier

[Thomas Colcombet]

hello,

I'd like to do something that looks like :

module A =
  (struct
     type t = { mutable field : int }
  end : sig
     type t = { field : int }
  end)

This is not allowed by ocaml, however
I think it would be useful  if the mutable
field is modified, let's say, only during the
construction of terms of type t, but must not
be modified outside the module (for consistency
reasons).
Is there any typing or implementation issue
which prevents such mutable modifier hiding ?

	Thom

Re: hiding the 'mutable' modifier

[Markus Mottl]

> I'd like to do something that looks like :
> 
> module A =
>   (struct
>      type t = { mutable field : int }
>   end : sig
>      type t = { field : int }
>   end)

The usual idea of a module is to hide the concrete implementation of some
data type and to provide for functions that only allow the kind of access
you want.

So you could write, e.g.:

  module A :
    sig
      type t
      val field : t -> int
    end =

    struct
      type t = { mutable field : int }

      let field x = x.field
      let internal_only x n = x.field <- n
    end

As you can see, the signature to which "A" is restricted, does not show how
"t" is implemented (mutable/nonmutable, whatever).

It only provides for a function "field" that allows read-only access to the
field in type t. However, the user of this module would not (and need not)
even know that "t" is implemented as a record with a field of this name.
He would only have to write "field foo", for example, to get the
information needed.

Function "internal_only" destructively updates the record field, but it is
not visible to the outside, because it does not appear in the signature.

Regards,
Markus Mottl

-- 
Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl