On Sun, Oct 11, 2009 at 8:2= 4 AM, Jun Furuse <jun.furuse@gmail.com> wrote:

I have not tested it well but it counts dots and should try to find
the minimal one.

A problem I have found so far is that it prints something confusing, ex.
module M =3D struct type t end
module N =3D struct type t end
open M
open N

let _ =3D ( 1 : M.t )

>> Error: This expression has type int but an expression was expected= of type t =A0 =A0(which t ?!?!?)

If there are types M.t and N.t and the both of M and N are opened,
these types are printed just "t". This can be avoided by testing = the
result name "t" against the current typing envrionment to see it<= br> really means the original type "M.t". This requires more coding b= ut
the weekend has ended in the far east already :-) =A0 (It's 0:24 Monday=
now.)

Jun

On Mon, Oct 12, 2009 at 12:12 AM, Yaron Minsky <yminsky@gmail.com> wrote:
> Cool! =A0That was quick.
>
> Does this patch also implement stephen's fewest-number-of-dots heu= ristic? =A0I
> was thinking one nice approach would be fewest-number-of-dots with tie= s
> broken by length of final identifier.
>
> Y
>
> Yaron Minsky
>
> On Oct 11, 2009, at 10:57 AM, Jun Furuse <jun.furuse@gmail.com> wrote:
>
>> I have quickly wrote a small patch against 3.11.1 for this feature= , to
>> see what it would be like.
>>
>> http://sites.google.com/a/furuse.info= /jun/hacks/other-small-ocaml-patches
>>
>> With this patch, path names are printed without opened modules in = the
>> context. It also tries heuristic data type name simplification: if= a
>> variant/record data type is an alias of another data type whose na= me
>> is shorter than the original, the printer uses the latter.
>>
>> For example:
>>
>> # open Hashtbl;;
>> # let tbl =3D Hashtbl.create 10;;
>> val tbl : ('_a, '_b) t =3D <abstr> =A0 =A0 =A0(* not= Hashtbl.t, since Hashtbl is
>> open *)
>>
>> # type t =3D int;;
>> type t =3D int
>> # type long_name =3D int;;
>> type long_name =3D int
>> # (1 : t);;
>> - : t =3D 1 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 (* t is the sh= orter than its original type
>> int *)
>> # (1 : long_name);;
>> - : int =3D 1 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 (* int is shorte= r name for long_name. t
>> is even shorter but not aliased unfortunatelly. *)
>>
>> I warn you that the patch is very quickly written and not tested w= ell.
>> Enjoy!
>>
>> Jun
>>
>> On Fri, Oct 9, 2009 at 10:53 AM, Yaron Minsky <yminsky@gmail.com> wrote:
>>>
>>> And you can compete to come up with the most innocuous code th= at comes up
>>> with the longest type. =A0Here's my current favorite:
>>>
>>> # open Option.Monad_infix;;
>>> # Map.find m 3 >>| fun x -> x + 1;;
>>> - : int Core.Std.Option.Monad_infix.monad =3D Some 4
>>>
>>> Which of course could be rendered as:
>>>
>>> # open Option.Monad_infix;;
>>> # Map.find m 3 >>| fun x -> x + 1;;
>>> - : int option =3D Some 4
>>>
>>> y
>>>
>>> On Thu, Oct 8, 2009 at 9:40 PM, Yaron Minsky <yminsky@gmail.com> wrote:
>>>>
>>>> Anyone who plays around with the Core library that Jane St= reet just
>>>> released can see showcased a rather ugly detail of how Cor= e's design
>>>> interacts with how OCaml displays types. =A0Witness:
>>>>
>>>> # Int.of_string;;
>>>> - : string -> Core.Std.Int.stringable =3D <fun> >>>> # Float.of_string;;
>>>> - : string -> Core_extended.Std.Float.stringable =3D &l= t;fun>
>>>>
>>>> I'd be much happier if this was rendered in the follow= ing equally
>>>> correct
>>>> and more readable form:
>>>>
>>>> # Int.of_string;;
>>>> - : string -> Int.t =3D <fun>
>>>> # Float.of_string;;
>>>> - : string -> Float.t =3D <fun>
>>>>
>>>> Or even:
>>>>
>>>> # Int.of_string;;
>>>> - : string -> int =3D <fun>
>>>> # Float.of_string;;
>>>> - : string -> float =3D <fun>
>>>>
>>>> And this isn't just an issue in the top-level. The com= piler also
>>>> displays
>>>> types in the same difficult to read form. =A0I'm wonde= ring if anyone has
>>>> some
>>>> thoughts as to what we can do to make the compiler make be= tter choices
>>>> here. =A0There are two issues to overcome:
>>>>
>>>> Dropping the module name. =A0I'd love to give the comp= iler the hint that
>>>> Core.Std. could be dropped from the prefix in a context wh= ere that
>>>> module is
>>>> open. =A0This is what's done with the pervasives modul= e already, I
>>>> believe, so
>>>> it seems like it should be doable here.
>>>> Choosing shorter names. =A0This one seems harder, but ther= e are various
>>>> different possibilities for what type name to print out, a= nd a
>>>> reasonable
>>>> heuristic to use might be to pick the shortest one. =A0Par= t of the reason
>>>> these issues come up is our use of standardized interface = components
>>>> (that's
>>>> where the "stringable" type name comes from). = =A0I suspect this one will
>>>> be
>>>> hard to fix, sadly.
>>>>
>>>> Anyway, we'd be happy with any suggestions on how to i= mprove matters.
>>>>
>>>> y
>>>
>>>
>>> _______________________________________________
>>> Caml-list mailing list. Subscription management:
>>> http://yquem.inria.fr/cgi-bin/mailman/listinfo/cam= l-list
>>> Archives: h= ttp://caml.inria.fr
>>> Beginner's list: http://groups.yahoo.com/group/ocaml_begi= nners
>>> Bug reports: http://caml.inria.fr/bin/caml-bugs
>>>
>>>
>

_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list Archives: http://caml.in= ria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs