Bind monadic variables over several functions

Question

I'm interested in getting as close as possible to the following syntax. TH is just fine by me.

bootapplication :: IO ()
bootapplication = do
  clientA <- newChan :: IO (Chan AMsg)
  clientB <- newChan :: IO (Chan BMsg)
  ...
  magicHappens


doSomething :: SomeSortaMonadTOnIO ()
doSomething = do
  writeChan clientA aMsg
  writeChan clientB bMsg

I suppose the following is acceptable

main = do
    clientA <- newChan :: IO (Chan [Char])
    clientB <- newChan :: IO (Chan Whatever)
    let a = putStrLn . (++) "a"
    let moof = do
--      b "hello"
        a "hi"
--      d "meh"
        readChan clientA
        return ()
    let b = putStrLn . (++) "b"
    let d = putStrLn . (++) "c" 
    return ()

But the commented lines are unacceptable since a let binding only works going forward. How do I hammer and duct tape ghc into letting me do this?

Edit:

Here's the syntax I settled on

main = do
    clientA <- newChan :: IO (Chan [Char])
    clientB <- newChan :: IO (Chan Whatever)
    let {

a :: [Char] -> IO ()
;a = putStrLn . (++) "a"

;moof :: IO ()
;moof = do 
    a "a"
    b "b"

;b :: [Char] -> IO ()
;b = putStrLn . (++) "b"

;d :: [Char] -> IO ()
;d = putStrLn . (++) "c"


}
    moof
    return ()

Nikita Volkov · Accepted Answer · 2013-05-23T08:33:20.873

Answering your exact question, just unite those lines in a single let block:

main = do
  clientA <- newChan :: IO (Chan [Char])
  clientB <- newChan :: IO (Chan Whatever)
  let 
    a = putStrLn . (++) "a"
    moof = do
      b "hello"
      a "hi"
      d "meh"
      readChan clientA
      return ()
    b = putStrLn . (++) "b"
    d = putStrLn . (++) "c" 
  return ()

Alternatively you can use where, which is more conventional to store function definitions in, as it is in your case:

main = do
  clientA <- newChan :: IO (Chan [Char])
  clientB <- newChan :: IO (Chan Whatever)
  let 
    moof = do
      b "hello"
      a "hi"
      d "meh"
      readChan clientA
      return ()
  return ()
  where
    a = putStrLn . (++) "a"
    b = putStrLn . (++) "b"
    d = putStrLn . (++) "c"

From the above code it's easy to trace that moof will in fact never get executed, because let a = b inside a do block is just a sugar for a <- return b. So I guess what you intended in fact was the following:

main = do
  clientA <- newChan :: IO (Chan [Char])
  clientB <- newChan :: IO (Chan Whatever)
  moof <- do
    b "hello"
    a "hi"
    d "meh"
    readChan clientA
    return ()
  return ()
  where
    a = putStrLn . (++) "a"
    b = putStrLn . (++) "b"
    d = putStrLn . (++) "c"

I mean all the functions are more likely to look like moof, so I can't really move them out of the way. But, it's cool that let can bind multiple things like that. Okay, so is there any way to get the stuff in the let block in your first code segment unindented? That's my ultimate goal. — Evan, May 23 '13 at 08:23
@Evan These are syntactic rules of a language, you can't get around that. But I think you don't even need to bother about, because there were some fundamental mistakes in your question. See the update to my answer. — Nikita Volkov, May 23 '13 at 08:30
I wasn't terribly interested in how the segment would execute. It was just to show the syntax I was interested in. — Evan, May 23 '13 at 08:37

Bind monadic variables over several functions

1 Answers1