[Haskell-cafe] sharing
Tom Schouten
tom at zwizwa.be
Wed Feb 5 15:37:10 UTC 2020
On 2/5/20 8:17 AM, Carter Schonwald wrote:
>
> Have you looked at how stuff like the ivory/tower edsl libraries do
> their embedding?
>
That is a nice project! Thanks for pointing it out.
For Ivory, the embedding is monadic so not any different in that
respect, and this is also much more expressive than what I need.
I guess I don't know what exactly I don't know...
I'm doing something quite straightforward. Basically I know that the
language I'm embedding only has pure functions mapping pairs of
sequences to pairs of sequences with the restriction that the mapping is
causal when you look at individual elements in a stream, but I dont'
think this fact is even observable after abstracting to streams.
Keeping track of the sharing information necessary to be able to compile
it to an external target introduces an effect. But this is the _only_
effect, and it is an implementation detail that makes me loose all the
nice properties of pure functions. That just feels wrong. I'm sure I'm
missing something.
I believe the core issue is that I'm not understanding something quite
fundamental. Why is it so hard to recover sharing information if the
thing that is embedded is pure? I suspect the answer is something
something referential transparency but how exactly?
This is what I sort of understand:
- Compiling to categories fixes the problem completely using a big gun:
abstracting over function abstraction and application. It's great, but
can't be done in Haskell as is. This is probably the cleanest solution.
I suspect this also has the answer to my question above but I don't
quite see it.
- There is another Functional HDL that solves this using some unsafe
reference trick to keep track of the sharing. I believe it is CλaSH but
I'm not sure. I believe you can get away with this because the semantics
is pure so in practice doesn't cause any inconsistencies, but it really
doesn't sound like something I would do without some kind of proof that
it is actually ok. If it is ok, it would probably make sense to abstract
this in a library. Maybe someone has done that already?
- You can try to recover sharing later by doing common subexpression
elimination. This works but has complexity issues and doesn't scale to
large systems.
- Maybe it is possible to hide the compiler using existential types. I
tried something along these lines but I couldn't figure it out so I
don't know if it's just lack of insight or just impossible. Probably the
latter.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20200205/a7570885/attachment.html>
More information about the Haskell-Cafe
mailing list