Re: [Caml-list] Warnings opening modules (was: why is building ocaml hard?)

[Yotam Barnoy <yotambarnoy@gmail.com>]

That's right -- I haven't touched our Haskell code in a while and
forgot about this detail.

It's nice to know that this is possible in ocaml, but it's clearly
inadequate for manually importing constructors. Perhaps this aspect
(importing constructors) should be improved, since the others can be
emulated. Or maybe open should be enhanced.

While thinking about open, it would also be nice to think of similarly
adequate solutions for modules that aren't opened but are still
limited to a specific interface (qualified importing in Haskell).

 A solution that covers both cases with minimal changes would
obviously be ideal.

> On Jul 15, 2016, at 3:52 PM, Jeremy Yallop <yallop@gmail.com> wrote:
>
>> On 15/07/2016, Yotam Barnoy <yotambarnoy@gmail.com> wrote:
>>> On Jul 15, 2016, at 3:26 PM, Hezekiah M. Carty <hez@0ok.org> wrote:
>>> On Fri, Jul 15, 2016 at 2:58 PM Yotam Barnoy <yotambarnoy@gmail.com> wrote:
>>>>>> On Jul 15, 2016, at 2:09 PM, Jeremy Yallop <yallop@gmail.com> wrote:
>>>>>> On 15 July 2016 at 17:57, Yotam Barnoy <yotambarnoy@gmail.com> wrote:
>>>>>> In haskell, I can just say 'import A (foo, bar, baz, t)' to limit
>>>>>> exactly what I want to import. This is because haskell has a
>>>>>> half-baked module system that isn't nearly as powerful as OCaml's,
>>>>>> which allows it to create syntax that doesn't need to go anywhere but
>>>>>> at the toplevel.
>>>>>>
>>>>>> We need this functionality in OCaml, but the closest thing is to say
>>>>>> 'include struct let foo = A.foo let bar = A.bar let baz = A.baz type t
>>>>>> = A.t end'
>>>>>
>>>>> This can be written more succinctly:
>>>>>
>>>>>  let foo, bar, baz = A.(foo, bar, baz)
>>>>>  type t = A.t
>>>>
>>>> Ok I have to admit that's pretty convenient.
>>> type t = M.t does not bring M.t's constructors into scope.  ppx_import (
>>> https://github.com/whitequark/ppx_import) can help with this if you don't
>>> mind preprocessing.
>>
>> That's a great point. Without that last bit of functionality, this isn't
>> really a solution to the problem.
>
> The Haskell example you gave:
>
>   import A(T)
>
> doesn't bring T's constructors into scope, either; it needs to be
> written like this:
>
>   import A(T(..))
>
> In OCaml you can bring A.t's constructors into scope by repeating the
> definition:
>
>   type t = A.t = T of int