On Thu, 2010-06-10 at 19:44 +0200, Martin Drautzburg wrote: > On Thursday, 10. June 2010 00:08:34 Luke Palmer wrote: > > > Or just: > > > > apply = val_of > > > So, to summarize: if you have something that isn't a function and you > > want to use it like a function, convert it to a function (using > > another function :-P). That's all. No syntax magic, just say what > > you're doing. > > Thanks Luke > > The reason I was asking is the following: suppose I have some code which uses > some functions, and what it primarily does with those functions is CALL them > in different orders. > > Now at a later point in time I decide I need to give names to those > functions > because at the end I need to print information about the functions which > together solved a certain problem. Think of my problem as "In which order do > I have to call f,g,h such that (f.g.h) 42 = 42?". > > I don't want to change all places where those functions are called > into "apply" style. Therefore I was looking for some idiom like the python > __call__() method, which, when present, can turn just about anything into a > callable. > > I could change the *definition* of my original functions into "apply" style > and the rest of the code would not notice any difference. But that does not > really help, because in the end I want to Show something like [g,h,f], but my > functions would no longer carry names. > > Alternatively I could associate functions with names in some association > function, but that function simply has to "know to much" for my taste. > > The thing is, I only need the names at the very end. Throughout the majority > of the computation they should stay out of the way. > >
data Named a = Named String a instance Functor Named where f `fmap` (Named s v) = Named s (f v) instance Applicative Named where pure x = Named "" x (Named s f) <*> (Named t v) = Named (s ++ "(" ++ t ++ ")") (f v) instance Eq a => Eq (Named a) where (Named _ x) == (Named _ y) = x == y instance Show (Named a) where show (Named s _) = s namedPure :: Show a => a -> Named a namedPure x = Named (show x) x test :: Num a => (a -> a) -> (a -> a) -> (a -> a) -> [String] test f g h = do [f', g', h'] <- permutations [Named "f" f, Named "g" g, Named "h" h] guard $ namedPure 42 == f' <*> g' <*> h' <*> namedPure 42 return $ show f' ++ " . " ++ show g' ++ " . " ++ show h' (code is not tested but it should work) Regards
signature.asc
Description: This is a digitally signed message part
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe