View source for DDC/PolymorphicUpdate

'''This is outdated information'''. The DDC project has moved to [http://discus-lang.org http://discus-lang.org]



== Get/Set ==
Consider the following function:

<haskell>
makeGetSet :: forall a. a -> (() -> a, a -> ())
makeGetSet x
 = do 	box	= Just x
	get ()	= case box of { Just z -> z; }
	set z	= box#x #= z
	(get, set)
</haskell>

This function allocates a box which can store a value, and returns a tuple of functions to get and set that value.

As the function is polymorphic, we can create boxes of whatever type we would like:

<haskell>
main ()
 = do	getSet :: (() -> Int, Int -> ())
        getSet	= makeGetSet 5

 	out $ fst getSet ()   -- prints '5'

	snd getSet 23         -- update the box
	out $ fst getSet ()   -- prints '23'
</haskell>

The trouble comes when we create a box containing a value of polymorphic type. Without closure typing we could define:

<haskell>
        ...
        getSet2 :: forall a. (() -> [a], [a] -> ())
        getSet2 = makeGetSet []
</haskell>

When a list is empty, we can treat it as being of any type <hask>(forall a. [a])</hask>, but suppose we update the box containing it at two different types...

<haskell>
       snd getSet2 [23]
       snd getSet2 ["trouble"]

       out $ fst getSet2 ()
</haskell>

The type of <hask>getSet2</hask> has <hask>forall a.</hask> at the front, so there is nothing to stop us from calling the set function at both <hask>[Int]</hask> and <hask>[String]</hask>, but what should the type be when use the get function in the last line?

== Dangerous type variables ==
Ultimately, the problem illustrated above arose because there wasn't a mechanism to track the sharing of data between successive calls to <hask>getSet2</hask>. When <hask>makeGetSet</hask> was evaluated it created a shared mutable object (the <hask>box</hask>) and then returned functions that had this object free in their closure.

In Disciple, <hask>makeGetSet</hask> has the full type:
<haskell>
makeGetSet
        :: forall a %r0 %r1
        .  a -> Tuple2 %r1 (() -(!e0 $c0)> a) (a -(!e1 $c1)> ())
        :- !e0        = !Read %r0
        ,  !e1        = !{!Read %r0; !Write %r0}
        ,  $c0        = ${box : %r0; box : %r0 $> a}
        ,  $c1        = ${box : %r0; box : %r0 $> a}
        ,  Base.Mutable %r0
</haskell>

In this type, we see the new closure term <hask>(box : %r0 $> a)</hask>. This term says that the closure contains an object named <hask>box</hask> which is in a region <hask>%r0</hask>, and the type of the object includes a variable <hask>'a'</hask>. When <hask>%r0</hask> is <hask>Mutable</hask> we say that <hask>a</hask> is ''dangerous'', and dangerous variables are never generalised when they are free in the (outer most) closure of a function.