[GHC Users] Dictionary sharing

[Edward Z. Yang]

I say "usually" because while I believe this to be true for the
current implementation of GHC, I don't think we necessary give
this operational guarantee.

But yes, your real problem is that there is a world of difference between
functions and non-functions.  You will need to use one of the usual tricks for
memoising functions, or forgo using a function altogether and lean on laziness.

Edward

Excerpts from Jonas Almström Duregård's message of Fri Jun 29 11:21:46 -0400 2012:
> Thank you for your response Edward,
> 
> You write that it is usually only evaluated once, do you know the
> circumstances under which it is evaluated more than once? I have some
> examples of this but they are all very large.
> 
> The real issue I was having was actually not with a list but with a
> memoised function i.e. something like:
> >>>
> class C a where
>   memoised :: Int -> a
> <<<
> 
> Perhaps functions are treated differently?
> 
> Regards,
> Jonas
> 
> On 29 June 2012 15:55, Edward Z. Yang <ezyang at mit.edu> wrote:
> > Hello Jonas,
> >
> > Like other top-level definitions, these instances are considered CAFs
> > (constant applicative forms), so these instances will in fact usually
> > be evaluated only once per type X.
> >
> >    import System.IO.Unsafe
> >    class C a where
> >        dflt :: a
> >    instance C Int where
> >        dflt = unsafePerformIO (putStrLn "bang" >> return 2)
> >    main = do
> >        print (dflt :: Int)
> >        print (dflt :: Int)
> >        print (dflt :: Int)
> >
> > ezyang at javelin:~/Dev/haskell$ ./caf
> > bang
> > 2
> > 2
> > 2
> >
> > Cheers,
> > Edward
> >
> > Excerpts from Jonas Almström Duregård's message of Fri Jun 29 07:25:42 -0400 2012:
> >> Hi,
> >>
> >> Is there a way to ensure that functions in a class instance are
> >> treated as top level definitions and not re-evaluated?
> >>
> >> For instance if I have this:
> >> >>>
> >> class C a where
> >>   list :: [a]
> >>
> >> instance List a => List [a] where
> >>   list = permutations list
> >> <<<
> >> How can I ensure that list :: [[X]] is evaluated at most once for any
> >> type X (throughout my program)?
> >>
> >> I assume this is potentially harmful, since list can never be garbage
> >> collected and there may exist an unbounded number of X's.
> >>
> >> I currently have a solution that uses Typeable to memoise the result
> >> of the function based on its type. Is there an easier way?
> >>
> >> Regards,
> >> Jonas
> >>