úÎ8±6      Safe-Infered"A memoization class. An instance  T for some  type T means that that  method can memoize for  parameters of type T. None To derive % instances for the given data types. " In the simplest usage, to derive  for an algebraic  datatype named T , write:    deriveMemoizable ''T -This assumes that all the type parameters of T that are not " annotated with a kind other than * should be listed as requiring  8 instances in the instance context. For example, given  a data type declared as   " data T a (b :: * -> *) c = ... &the generated instance will look like    instance ( a,  c) =>   (T a b c) where ... /For more precise control over the context, use  .  N.B.: The TemplateHaskell+ language extension must be enabled to use  this function. Like . but takes a second argument, which is a list  of 9s to specify which type parameters of the type should be G mentioned in the context. For example, given the same definition for  T as above, we can write    deriveMemoizableParams ''T [3]  to leave the first parameter of T out of the context and show ' only the third, yielding the instance    instance  c =>  (T a b c) where ...  N.B.: The TemplateHaskell+ language extension must be enabled to use  this function. In cases where neither  nor  ) can figure out the right context for an E instance declaration, one can declare the instance manually and use - this function to derive the method body for . For example,  suppose that a data type T is defined as:    data T a b = T (a -> Bool) b For T a b to be memoizable,  a -> Bool must be, and based on the  instance for '(->)', this means that a must satisfy   and , so  cannot build the right  context for the $ instance. Instead, one can write:   instance ( a,  a,  b) =>   (T a b) where  memoize = $(deriveMemoize ''T) None Memoize a two argument function "Memoize a three argument function !Memoize a four argument function !Memoize a five argument function  Memoize a six argument function "Memoize a seven argument function ;Memoizes the least fixed point of a function. This is like  ., but it passes the fixed function a memoized H version of itself, so this memoizes using all recursive calls as well. Two argument version of  . Three argument version of  . Four argument version of  . Five argument version of  . Six argument version of  . Seven argument version of  . 6Give a one-argument function whose argument satisfies , E this memoizes the function such that the argument is shown (using  /) only when the function has to be applied, as > opposed to when the answer is available in the memo cache.  Can be used to memoize over any finite type satisfying   and .. This builds a binary search tree, treating / the memoized type as isomorphic to a range of , so it will be  only as efficient as , , , and . FThis can be used to make instances for finite types. For example, the  instances for  and  are declared as:  9 instance Memoizable Int where memoize = memoizeFinite : instance Memoizable Char where memoize = memoizeFinite %  !"#$%&'()*+,-./0123  %  !"#$%&'()*+,-./01234      !"#$%&'()*+,-./0123456789:;<=>?@ memoize-0.2Data.Function.MemoizeData.Function.Memoize.ClassData.Function.Memoize.TH Data.Functionfix MemoizablememoizederiveMemoizablederiveMemoizableParams deriveMemoizememoize2memoize3memoize4memoize5memoize6memoize7memoFixmemoFix2memoFix3memoFix4memoFix5memoFix6memoFix7 traceMemoize memoizeFiniteghc-prim GHC.TypesIntbaseGHC.EnumBoundedEnumGHC.ShowShow Debug.TracetracetoEnumfromEnumsuccpredChar$fMemoizable()$fMemoizableBool$fMemoizableOrdering$fMemoizableMaybe$fMemoizableEither$fMemoizable[]$fMemoizable(,)$fMemoizable(,,)$fMemoizable(,,,)$fMemoizable(,,,,)$fMemoizable(,,,,,)$fMemoizable(,,,,,,)$fMemoizable(,,,,,,,)$fMemoizable(,,,,,,,,)$fMemoizable(,,,,,,,,,)$fMemoizable(,,,,,,,,,,)$fMemoizable(->)$fMemoizableChar$fMemoizableInt$fMemoizableFinite$fMemoizableInteger$fMemoizable(,,,,,,,,,,,)