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

[Malcolm Matalka <mmatalka@gmail.com>]

Ah great!  What you said works!  The problem I was running into was
trying to do Map.Make(Bar).  Still getting used to how Core organizes
things.

I looked around a bit on google as well but couldn't find an answer to
this: what is the difference between = and := in a 'with'?  The
language reference section I looked at didn't seem to make a
distinction.

Thanks again,
/M

On Wed, Sep 19, 2012 at 9:51 AM, David House <dmhouse@gmail.com> wrote:
> Oh, and one more thing to mention. If your identifier types are not
> strings, but you have of_string and to_string functions, then you can
> do the following:
>
> module Bar = struct
>   module T = struct
>     type t = ...
>     let of_string = ...
>     let to_string = ...
>   end
>   include Identifiable.Of_stringable(T)
> end
>
> module Bar : Identifiable
>
> On 19 September 2012 08:49, David House <dmhouse@gmail.com> wrote:
>> 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
>>>>