On 25/05/11 10:00, Jonas Almström Duregård wrote:
As an equivalent to:
f (x a) (y b) (z c)
Of course my intention is that the new keyword should initiate layout syntax so we can write this:
f <applied to> x a y b z c
Here's a (tongue-in-cheek) trick that allows for layout close to what you wanted (spoiler: but not close enough!). We start by switching to parameterised monads (which allow you to change the type of the monad as you go down the do-block; look carefully at the second and third parameters in the monad class): {-# LANGUAGE RebindableSyntax #-}
import Control.Applicative import Prelude ((++), (.), Num(..), Eq(..), ($), id, Int, Char, String, Float, ?, const, Show(..), Fractional(..))
class Monad m where (>>=) :: m a b y -> (y -> m b c z) -> m a c z return :: b -> m a a b
(>>) :: Monad m => m a b y -> m b c z -> m a c z (>>) m n = m >>= const n
Then we define a type for wrapping pure functions in this monad:
data Fun a b c = Fun (a -> b) c
instance Monad Fun where (>>=) (Fun f x) m = let Fun g y = m x in Fun (g . f) y return x = Fun id x
Then we add a helper for unwrapping it:
($$) :: a -> Fun a b c -> b ($$) f (Fun g _) = g f
And a function for supplying an argument:
r :: a -> Fun (a -> b) b a r x = Fun ($ x) x
And so what does let us do? Well, here's how it's used:
foo :: Int -> Char -> String -> Float -> String foo a b c d = show (a, b, c, d)
eg :: String eg = foo $$ do r$ 2 + 1 r$ 'c' r$ "hello" ++ "goodbye" r$ 3.0
foo is the function we want to apply, and eg shows how to apply it in do-notation with an argument on each line. I couldn't manage to remove the r$ at the beginning of each line, which rather ruins the whole scheme :-( On the plus side, there's no brackets, it's only two extra characters per line, and you can have whatever you like after the r$. For those who are interested, you can also use the same trick for writing Applicatives in a do notation. Continuing the same module, we can add an analogue for each of the types and functions for Applicative:
data App f a b c = App (f a -> f b) c
instance Applicative f => Monad (App f) where (>>=) (App f x) m = let App g y = m x in App (g . f) y return x = App id x
(<$$>) :: Applicative f => f a -> App f a b c -> f b (<$$>) f (App g _) = g f
s :: Applicative f => f a -> App f (a -> b) b (f a) s x = App (<*> x) x
Then we can use this on things which are Applicative but not Monad, e.g.
egA :: [String] egA = getZipList $ pure foo <$$> do s$ ZipList [3, 6, 7] s$ ZipList "hello" s$ ZipList ["more", "strings"] s$ ZipList [1.0, 1.5, 2.0]
And that's enough silly playing around :-) Thanks, Neil.