Re: [Caml-list] Expressing module sig and impl in mli file

[David House <dmhouse@gmail.com>]

So, this depends. If you have an identifier type that are internally
just strings, then the simplest way is as I said before:

module Bar = String_id (* or = String, both will work *)

module Bar : sig
  type t
  include Identifiable with type t := t
  (* other operations on your Bar go here *)
end

The Identifiable signature includes the Comparable signature, which
includes a map module. So then you have a type ['a Bar.Map.t], which
is a map from Bar.t's to 'a.

If you want to use your own comparison function, then you can do the following:

module Bar = struct
  module T = struct
    type t = string with sexp
    let compare = ...
  end
  include T
  include Comparable.Make(T)
  let of_string = Fn.id
  let to_string = Fn.id
end

module Bar : sig
  type t
  include Comparable with type t := t (* Map module, compare, etc. *)
  include Strinagable with type t := t (* to_string, of_string *)
end

This will generate a map module that uses the comparison function you define.

If additionally you can define a hash function, then you can do the following:

module Bar = struct
  module T = struct
    type t = string with sexp
    let compare t1 t2 = ...
    let hash t = ...
  end
  include T
  include Comparable.Make(T)
  include Hashable.Make(T)
  let of_string = Fn.id
  let to_string = Fn.id
end

module Bar : sig
  type t
  include Comparable with type t := t (* Set module, Map module,
compare, etc. *)
  include Strinagable with type t := t (* to_string, of_string *)
  include Hashable with type t := t (* hash, Table module, Hash_set
module, etc. *)
end

And the final signature is actually equal (very nearly) to
Identifiable, so you'd just write:

module Bar : Identifiable

On 19 September 2012 08:36, Malcolm Matalka <mmatalka@gmail.com> wrote:
> Yes I think I'm confused.  In all parts of this module I want the
> Identifiable behaviour, but at the same time I want a Map of these
> identifiers to something, so this turned in to me trying to jerry-rig
> that rather than thinking about what I actually want.
>
> Can something that is Identifiable be the key to a Map (in Core)?  Am
> I doing something wrong if I want that?
>
> Thanks
>
> /M
>
> On Wed, Sep 19, 2012 at 9:11 AM, David House <dmhouse@gmail.com> wrote:
>> The standard way of doing this is as follows (note that Identifier is
>> changing to Identifiable in the next version, so I'll use that
>> terminology):
>>
>> module Bar : sig
>>   type t = string
>>   include Identifiable with type t := t
>> end
>>
>> But if this is literally what you're doing, I'm sort of confused. The
>> point of identifiable is that you have explicit to_string/from_string
>> functions and the type equality with string is not exposed. E.g. you
>> might want to use a different comparison function than string
>> equality. If you expose the type equality with string, then people are
>> free to use String.compare on your type, so you don't get the
>> abstraction you wanted.
>>
>> --
>> Caml-list mailing list.  Subscription management and archives:
>> https://sympa-roc.inria.fr/wws/info/caml-list
>> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
>> Bug reports: http://caml.inria.fr/bin/caml-bugs
>>