[Haskell-cafe] Re: How to "Show" an Operation?
Daniel Fischer
daniel.is.fischer at web.de
Thu Jun 10 18:12:03 EDT 2010
On Thursday 10 June 2010 23:38:15, Martin Drautzburg wrote:
> On Thursday, 10. June 2010 22:10:08 Maciej Piechotka wrote:
>
> Wow!
>
> this is somewhat above my level. I guess I need to go back to the books.
> I'll document my ignorance nontheless.
>
> > data Named a = Named String a
> >
> > instance Functor Named where
> > f `fmap` (Named s v) = Named s (f v)
>
> okay so far
>
> > instance Applicative Named where
> > pure x = Named "" x
> > (Named s f) <*> (Named t v) = Named (s ++ "(" ++ t ++ ")") (f v)
>
> Applicative. Need to study that
> Control.Applicative (<*>) :: Applicative f => f (a -> b) -> f a -> f b
>
> So in our case the Applicative is a "Named".
Here, we define (<*>) for the type
(<*>) :: (Named (a -> b)) -> (Named a) -> (Named b)
(redundant parentheses against ambiguity errors).
A 'Named' thing is a thing together with a name.
So how do we apply a function with a name to an argument with a name?
What we get is a value with a name. The value is of course the function
applied to the argument ignoring names. The name of the result is the
textual representation of the function application, e.g.
Named "sin" sin <*> Named "pi" pi ~> Named "sin(pi)" 1.2246063538223773e-16
(<*>) is application of named functions to named values, or 'lifting
function application to named things'.
> When I apply a Named to a
> function, then I get a function between the corresponding Named types.
> When I pass it an Int->Char function, I get a Named Int -> Named Char
> function.
>
> But here it is applied to another Named ... is that the (a->b)?
> Puzzeled.
>
> > instance Eq a => Eq (Named a) where
> > (Named _ x) == (Named _ y) = x == y
> >
> > instance Show (Named a) where
> > show (Named s _) = s
>
> Understood.
>
> > namedPure :: Show a => a -> Named a
> > namedPure x = Named (show x) x
>
> When I can show something I can always name it so its name is what
> 'show' would return. Okay I guess I got it. This turns a "showable" into
> a Named.
>
> > 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]
>
> According to Hoogle permutations should be in Data.List. Mine (GHCI
> 6.8.2) does not seem to have it. Seems to have something to do with
Upgrade. We're at 6.12 now!
Lots of improvements.
permutations was added in 6.10, IIRC.
> "base", whatever that is.
>
> > guard $ namedPure 42 == f' <*> g' <*> h' <*> namedPure 42
>
> Ah, the 42 needs namedPure.
Simplest way, it could be
Named "answer to Life, the Universe and Everything" 42
> Again this <*> operator...
> I believe the whole thing is using a List Monad.
>
> > return $ show f' ++ " . " ++ show g' ++ " . " ++ show h'
>
> I wonder if the thing returns just one string or a list of strings. I
A list, one string for every permutation satisfying the condition.
> guess "return" cannot return anything more unwrapped than a List, so it
> must be a List. But does it contain just the first match or all of them?
> All of them! And how many brackets are around them?
do x <- list
guard (condition x)
return (f x)
is syntactic sugar for
concat (map (\x -> if condition x then [f x] else []) list)
More information about the Haskell-Cafe
mailing list