StrategyLib - need help
I want to write generic traversal which prints everything on the way: uglyPrint :: (Term t, Show t) => t -> [(String)] uglyPrint = (map snd) . runIdentity . applyTU (full_tdTU uglyPrintStep) uglyPrintStep :: (Show t, Term t) => TU [(t, String)] Identity uglyPrintStep = constTU [] `adhocTU` (return . uglyPrintAny) uglyPrintAny x = [(x,show x)] ugliestPrintEver :: (Term t, Show t) => t -> IO () ugliestPrintEver x = do { putStrLn $ show x } Compiler (GHC 6.0) gives me: Ambiguous type variable `t' in these top-level constraints: `Term t' arising from use of `uglyPrintStep' at ... `Show t' arising from use of `uglyPrintStep' at ... All data types which are instances of Term are instances of Show as well - I know it. Question is - how to persuade GHC? I there any want to use typeclass restrictions with traversal, or there is no luck for me? -- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D
Very good point! adhoc and friends support TYPE case. What's needed here is a so-far unsupported type-CLASS case which is actually at least non-trivial. I can only offer semi-solutions: a) Add a class constraint for Show to the Term class. (Would that work? It's a bit invasive anyway.) b) Alternatively, imoort TermRep and use explode and then show on TermRep. (This show maybe does not look so nice, but this should be good enough for debugging.) c) Be more specific about what terms to print, say have type-specific cases for types of terms of interest. (This would be reasonable if you only care about a few types, or there are even just a few types anyway.) On the long term: the "boilerplate" approach as supported in > GHC 6.0 will help with this. (In fact, the GHC 6.0 release comes with a simple gshow defined on Data.) StrategyLib will soon be reconstructed on top of "scrap your boilerplate" (say, Data.Generics). The issue of type-class case is identified, but I don't know if we will succeed with this very soon. Hope this helps. Ralf Dmitry Astapov wrote:
I want to write generic traversal which prints everything on the way:
uglyPrint :: (Term t, Show t) => t -> [(String)] uglyPrint = (map snd) . runIdentity . applyTU (full_tdTU uglyPrintStep) uglyPrintStep :: (Show t, Term t) => TU [(t, String)] Identity uglyPrintStep = constTU [] `adhocTU` (return . uglyPrintAny) uglyPrintAny x = [(x,show x)] ugliestPrintEver :: (Term t, Show t) => t -> IO () ugliestPrintEver x = do { putStrLn $ show x }
Compiler (GHC 6.0) gives me: Ambiguous type variable `t' in these top-level constraints: `Term t' arising from use of `uglyPrintStep' at ... `Show t' arising from use of `uglyPrintStep' at ...
All data types which are instances of Term are instances of Show as well - I know it. Question is - how to persuade GHC?
I there any want to use typeclass restrictions with traversal, or there is no luck for me?
-- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D _______________________________________________ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
-- Ralf Laemmel VU & CWI, Amsterdam, The Netherlands http://www.cs.vu.nl/~ralf/ http://www.cwi.nl/~ralf/
Evening, Ralf. Ralf Laemmel <Ralf.Laemmel@cwi.nl> 20:27 24/7/2003 wrote: RL> a) Add a class constraint for Show to the Term class. RL> (Would that work? It's a bit invasive anyway.) Yes, that a bit invasive to say at least. With equal "ease" I can hack DrIFT to produce instances of Show the way I want them. RL> b) Alternatively, imoort TermRep and use explode and then show on RL> TermRep. (This show maybe does not look so nice, RL> but this should be good enough for debugging.) I dont quite follow you here. If I (show . explode) the topmost Term, I got just the name of the type of that term. If I try to build a traversal which "explode"-s everything on the way, I got the same error as before (which is expected, I believe). RL> c) Be more specific about what terms to print, RL> say have type-specific cases for types of terms of interest. (This RL> would be reasonable if you only care about a few types, RL> or there are even just a few types anyway.) Thing is that there is a lot of types and I'd like to print all of them. -- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D
(Let's go to haskell-cafe if we want to continue.) Hi Dmitry, Sigh. Indeed, the distributed instance Show TermRep is not fit. The default TermRep in the Strafunski distribution is not even willing to disclose constructor names. So there is no way unless you tweak TermRep (and DrIFT). TermRep should hold a string component for the constructor (or the string representation in the case of primitive types). I will provide a StrategyLib on top of Data.Generics very soon. Then your trouble is gone. (The "Scrap Your Boilerplate" approach is really much more convenient.) As a quick fix, I advise you to code a monster switch as follows. (Tested in StrategyLib/examples/little-lambda) testShow :: [String] testShow = runIdentity (applyTU (full_tdTU myShowTU) expr4) where myShowTU = constTU [] `adhocTU` (\(x::Expr)-> return [show x]) `adhocTU` (\(x::Type)-> return [show x]) `adhocTU` (\(x::Identifier)-> return [show x]) So this is one line per type. Not that bad. And it is nice because you can comment out types easily during debugging. Greetings, Ralf
RL> a) Add a class constraint for Show to the Term class. RL> (Would that work? It's a bit invasive anyway.) Yes, that a bit invasive to say at least. With equal "ease" I can hack DrIFT to produce instances of Show the way I want them.
RL> b) Alternatively, imoort TermRep and use explode and then show on RL> TermRep. (This show maybe does not look so nice, RL> but this should be good enough for debugging.) I dont quite follow you here. If I (show . explode) the topmost Term, I got just the name of the type of that term. If I try to build a traversal which "explode"-s everything on the way, I got the same error as before (which is expected, I believe).
RL> c) Be more specific about what terms to print, RL> say have type-specific cases for types of terms of interest. (This RL> would be reasonable if you only care about a few types, RL> or there are even just a few types anyway.) Thing is that there is a lot of types and I'd like to print all of them.
-- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D _______________________________________________ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell
-- Ralf Laemmel VU & CWI, Amsterdam, The Netherlands http://www.cs.vu.nl/~ralf/ http://www.cwi.nl/~ralf/
Hi All, I am trying to perform dynamic casting on polymorphic types. Let's say I have a data type like:
data Foo a = Foo a
Is there any way to use dynamics to convert a value of type Foo a to a type reprentation? I try to use the toDyn in the dynamic libray, it complains for ambigours a. Is there a solution to it? Thank you very much. -W-M- @ @ | \_/
participants (3)
-
Dmitry Astapov -
Ralf Laemmel -
Wang Meng