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)