Re: [Caml-list] A shallow option type

[Andreas Rossberg <rossberg@mpi-sws.org>]

I should add that, even if "shallow options" where easy to achieve,  
they are really a bad idea. You can witness that in "dynamic"  
languages, where the lack of types leads everybody to just use the  
equivalent of non-disjoint unions, and thus shallow options. This can  
lead to an inflation of null-like sentinel values.

Consider e.g. JavaScript. Originally, there was `null`. Then they saw  
the need to distinguish an unbound variable from one bound to null  
(i.e., distinguish `None` from `Some None`) -- and `undefined` was  
born. Fast forward, `undefined` has proliferated to all sorts of APIs,  
and there is a desire to be able to treat it as proper value in many  
places, e.g. be able to store it in maps. Now there are recurring  
discussions how to introduce other sentinel values to distinguish  
"absent" from "mapped to `undefined`".

With a properly compositional, algebraic option type this mess cannot  
arise.

/Andreas


On May 5, 2012, at 16.48 h, Andreas Rossberg wrote:

> On May 5, 2012, at 15.33 h, Goswin von Brederlow wrote:
>> What I want is a
>>
>>   type 'a shallow = NULL | 'a  (constraint 'a != 'b shallow)
>
> This is a form of negation, which cannot be expressed in  
> conventional type systems. Just consider what it should mean in the  
> presence of type abstraction: if you have
>
>  M : sig
>    type t
>    ...
>  end
>
> would `M.t shallow` be a legal type? You couldn't decide that  
> properly without requiring that _every_ abstract type in every  
> signature is annotated with a constraint saying that it is "not  
> shallow".
>
>> I have some ideas on how to implement this in a module as abstract  
>> type
>> providing get/set/clear functions, which basically means I map None  
>> to a
>> C NULL pointer and Some x to plain x. I know x can never be the NULL
>> pointer, except when someone creates a 'a shallow shallow and sets  
>> Some
>> None. That would turn into simply None.
>
> And how do you know that nobody else implements a _different_ type,  
> say shallow2, that does the same thing? And a third party then  
> constructs a value of type `int shallow2 shallow`?
>
> It seems to me that what you want effectively is a special case of  
> non-disjoint union. Unfortunately, those are known to come with all  
> kinds of problems, such as not being compositional.
>
> /Andreas
>
>
> -- 
> 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
>