Thank you Benedikt! Thanks to your help I also figured out the way to do it using type families yesterday:
-------- class Pro p where type I p type O p re :: p → [I p → O p] instance Pro (b → c) where type I (b → c) = b type O (b → c) = c re = repeat instance Pro [b → c] where type I [b → c] = b type O [b → c] = c re = cycle broadcast :: Pro p ⇒ p → [I p] → [O p] ... -------- Regards, Cetin 2009/2/13 Benedikt Huber <benj...@gmx.net> > Cetin Sert schrieb: > > Thank you for your answer! > > > > This comes close to solving the problem but in the last line of the > > above I want to be able to say: > > > > either > > > print $ broadcast id [1..10] > > > > or > > > print $ broadcast [ (x +) | x ← [1..10] ] [1..10] > > > > both need to be possible*. > > > > So is there a way to make the FunList disappear completely? > Hi Cetin, > yes, if you're willing to use multi-parameter typeclasses: > > class Processor p b c | p -> b c where > > ready :: p -> [b -> c] > > instance Processor (b -> c) b c where > > ready = repeat > > instance Processor [b -> c] b c where > > ready = id > > broadcast :: Processor p b c => p -> [b] -> [c] > > Maybe there are other possibilities as well. > -- > benedikt > > > > > Regards, > > Cetin > > > > P.S.: * broadcast is a dummy function, I need this for tidying up the > > interface of a little experiment: http://corsis.blogspot.com/ > > > > 2009/2/13 Benedikt Huber <benj...@gmx.net <mailto:benj...@gmx.net>> > > > > Cetin Sert schrieb: > > > Hi, > > > > > > class Processor a where > > > ready :: (forall b c. a → [b → c]) > > > > > > instance Processor (b → c) where > > > ready = repeat > > > ... > > > ------------------------------- > > > Why can I not declare the above instances and always get: > > Hi Cetin, > > in your class declaration you state that a (Processor T) provides a > > function > > > ready :: T -> [b -> c] > > so > > > ready (t::T) > > has type (forall b c. [b -> c]), a list of functions from arbitrary > > types b to c. > > > > The error messages tell you that e.g. > > > repeat (f :: t1 -> t2) > > has type > > > (t1->t2) -> [t1->t2] > > and not the required type > > > (t1->t2) -> [a -> b] > > > > With your declarations, > > > head (ready negate) "hi" > > has to typecheck, that's probably not what you want. > > > > > Is there a way around this? > > > > Maybe you meant > > > > > class Processor a where > > > ready :: a b c -> [b -> c] > > > instance Processor (->) where > > > ready = repeat > > > newtype FunList b c = FunList [b->c] > > > instance Processor FunList where > > > ready (FunList fl) = fl > > > > I think the newtype FunList is neccessary here. > > benedikt > > > > > > > > message.hs:229:10: > > > Couldn't match expected type `b' against inferred type `b1' > > > `b' is a rigid type variable bound by > > > the instance declaration at message.hs:228:20 > > > `b1' is a rigid type variable bound by > > > the type signature for `ready' at message.hs:226:19 > > > Expected type: b -> c > > > Inferred type: b1 -> c1 > > > In the expression: repeat > > > In the definition of `ready': ready = repeat > > > > > > message.hs:229:10: > > > Couldn't match expected type `c' against inferred type `c1' > > > `c' is a rigid type variable bound by > > > the instance declaration at message.hs:228:24 > > > `c1' is a rigid type variable bound by > > > the type signature for `ready' at message.hs:226:21 > > > Expected type: b -> c > > > Inferred type: b1 -> c1 > > > In the expression: repeat > > > In the definition of `ready': ready = repeat > > > > > > message.hs:232:10: > > > Couldn't match expected type `b1' against inferred type `b' > > > `b1' is a rigid type variable bound by > > > the type signature for `ready' at message.hs:226:19 > > > `b' is a rigid type variable bound by > > > the instance declaration at message.hs:231:20 > > > Expected type: [b1 -> c] > > > Inferred type: [b -> c1] > > > In the expression: id > > > In the definition of `ready': ready = id > > > > > > message.hs:232:10: > > > Couldn't match expected type `c1' against inferred type `c' > > > `c1' is a rigid type variable bound by > > > the type signature for `ready' at message.hs:226:21 > > > `c' is a rigid type variable bound by > > > the instance declaration at message.hs:231:24 > > > Expected type: [b -> c1] > > > Inferred type: [b1 -> c] > > > In the expression: id > > > In the definition of `ready': ready = id > > > > > > Is there a way around this? > > > > > > Regards, > > > CS > > > > > > > > > > > > ------------------------------------------------------------------------ > > > > > > _______________________________________________ > > > Haskell-Cafe mailing list > > > Haskell-Cafe@haskell.org <mailto:Haskell-Cafe@haskell.org> > > > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > > > > > > ------------------------------------------------------------------------ > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe@haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > >
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
