L>>myCallback :: Signal -> StateT MyState IO ()
L>>myCallback signal = do
L>>    object <- liftIO $ getObjectFromFile (fileNameFromSignal signal)
L>>        objectList <- gets myObjects
L>>        modify $ updateObjectList (object : objectList)
L>>

do ref <- newIORef []
    f <- frame [text := "lse test"]
    incBtn  <- button f [text := "Inc", on command := modifyIORef ref updateMyList]
    printBtn <- button f [text := "Print", on command := (readIORef >>= print . reverse)]
where
    updateMyList xs = (length xs) : xs

Unlike more functional GUI libraries, wxHaskell does not provide a model for state management and uses simple mutable variables to communicate state across different event handlers. (Note: this is a concious design decision – as functional GUI interfaces are still very much a research area, we want to provide a full fledged GUI library using simple IO first, than try to build good functional interfaces on top of that).

type Var a = IORef a

newList = myCoolObject : oldList

test ss = do rs <- newIORef ss
             old <- readIORef rs
             writeIORef rs ('H' : tail old)
             new <- readIORef rs
             return (old, new)

*Main1> test "hello"
("hello","Hello")

L>>Нет

myCallback :: Signal -> StateT MyState IO ()
myCallback signal = do
    object <- liftIO $ getObjectFromFile (fileNameFromSignal signal)
        objectList <- gets myObjects
        modify $ updateObjectList (object : objectList)

test ss = do rs <- newIORef ss
             modifyIORef rs (\xs -> 'H' : tail xs)
             readIORef rs

L>myCallback :: Signal -> StateT MyState IO ()
L>myCallback signal = do
L>    object <- liftIO $ getObjectFromFile (fileNameFromSignal signal)
L>        objectList <- gets myObjects
L>        modify $ updateObjectList (object : objectList)
L>

main = do
    rs <- newIORef [1,2,3]
    test rs

test rs = do
oldRs <- readIORef rs
writeIORef rs ('1' : oldRs)
return rs

lse>main = do
lse>    rs <- newIORef [1,2,3]
lse>    test rs

lse>test rs = do
lse>oldRs <- readIORef rs
lse>writeIORef rs ('1' : oldRs)
lse>return rs
lse>

main = do
rs <- newIORef [1,2,3]
test rs

test rs = do
oldRs <- readIORef rs
writeIORef rs ('1' : oldRs)
return

modList lst@(x:xs) = (x+1):lst

{- Алгоритм на псевдокоде примерно такой:

void sort (Ord el => el arr[])
{
    int len = length (arr);

    for (int i = 1; i < len; i++)
    {
        for (int j = 0; j < i; j++)
        {
            if (arr [j] > arr [i])
            {
                (arr [i], arr [j]) = (arr [j], arr [i]);
            }
        }
    }
}

-}

import Data.IORef
import Control.Monad

sort arr = do
    let len = length arr
    forM [1..len-1] $ \i -> do
        forM [0..i-1] $ \j -> do
            arr'i <- arr !!! i
            arr'j <- arr !!! j
            when (arr'j > arr'i) $ do
                 (arr !! i) =:= arr'j
                 (arr !! j) =:= arr'i

main = do
    array <- toIORefs [ 10, 9..1 ]

    putStr   "Unsorted array: "
    printArr array

    sort     array

    putStr   "Sorted array:   "
    printArr array


arr !!! n = readIORef $ arr !! n
ref =:= n = writeIORef ref n

fromIORefs   = mapM readIORef
toIORefs     = mapM newIORef
printArr arr = fromIORefs arr >>= print

Unsorted array: [10,9,8,7,6,5,4,3,2,1]
Sorted array:   [1,2,3,4,5,6,7,8,9,10]