First, thanks for doing all of this. I'm not sure that I would have been able to understand the original ASAP paper without your thesis, and I think it's a fascinating space to explore for automatic memory management.
I have two questions about the paper. The first is the claim, in section 3.4, that "wild paths sets are, in general, not closed under + ... the + operator no longer serves to compute the meet of two paths". Are wild path sets not closed under + because a wild path has no defined return type? That is, if we took the wild path of a type Person { age : s64, name : string }, we have:
(Person . age) + (Person . name)
==>
Person . (age + name)
Which doesn't really make sense (but I didn't even need to take the meet of paths to create the situation). I'm just not totally certain what the claim in the paper means or what an example of it looks like.
The other question is about the super-linear slowdown in list_len.mmtn. The paper doesn't discuss why this happens. Based on my understanding of ASAP, I would expect that this could be caused by the tail of the list being traced over and over again before each recursive call to list_len. That would degrade performance from O(n) to O(n^2). But it doesn't seem like ASAP should cause this to happen. I wondered if you had any additional insight into what was going on.
First, thanks for doing all of this. I'm not sure that I would have been able to understand the original ASAP paper without your thesis, and I think it's a fascinating space to explore for automatic memory management.
I have two questions about the paper. The first is the claim, in section 3.4, that "wild paths sets are, in general, not closed under + ... the + operator no longer serves to compute the meet of two paths". Are wild path sets not closed under + because a wild path has no defined return type? That is, if we took the wild path of a type
Person { age : s64, name : string }, we have:Which doesn't really make sense (but I didn't even need to take the meet of paths to create the situation). I'm just not totally certain what the claim in the paper means or what an example of it looks like.
The other question is about the super-linear slowdown in
list_len.mmtn. The paper doesn't discuss why this happens. Based on my understanding of ASAP, I would expect that this could be caused by the tail of the list being traced over and over again before each recursive call tolist_len. That would degrade performance fromO(n)toO(n^2). But it doesn't seem like ASAP should cause this to happen. I wondered if you had any additional insight into what was going on.