GUIs in Haskell

• Mihai Maruseac
• 19th of June 2012

Cross-platform GUIs

• Java Swing, Java AWT
• GTK, wxWidgets, qt
• in C
  • how do we use them in Haskell?

FFI

• Foreign Function Interface
• wrap C functions and use them from Haskell code
• not the topic of this article
• GUI functions already wrapped for us

GTK

• GIMP Toolkit
• GTK+
• GNOME 3 -> GTK3
• cross-platform
• the most popular graphical interface in X Window System
• C, multiple bindings:
  • C++
  • Perl
  • Ruby
  • C#
  • Haskell
  • Python

Side effects?

• clicking a button is an action
• how can we manipulate actions?
  • while keeping code pure

IO

f1 = putStrLn "Hello World"
f2 = print 42

Prelude> :t putStrLn
putStrLn :: String -> IO ()
Prelude> :t print
print :: (Show a) => a -> IO ()
Prelude> :t readLn
readLn :: (Read a) => IO a

• IO a stands for an action which gives a result of type a
• Like a new data type but with no constructors
  • cannot pattern match
  • cannot use in case
  • cannot escape from IO
    • unsafePerformIO

In short, Haskell is the world’s finest imperative programming language - Simon Peyton Jones, Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell

Sequencing actions :: do notation

main = do
    n <- readLn
    print $ n + 1

main = do
    n <- readLn
    let ans = 42
    print $ n + ans

• looks like an imperative program
• how does it work?

Actions changing the world

main = do
    n <- readLn
    print $ n + 1

• main is the only action which is run
  • and only when the program is running

Monads

class Monad m where
    (>>=) :: m a -> (a -> m b) -> m b
    (>>) :: m a -> m b -> m b
    return :: a -> m a

• >>= looks like a pipeline feeding results from one computation to the next
• >> discards the results, used only for sequence
• return is only a function

main = do
    return 4
    print 5

List is a monad too!

instance  Monad []  where
    m >>= k  = foldr ((++) . k) [] m
    m >> k   = foldr ((++) . (\ _ -> k)) [] m
    return x = [x]

g l1 l2 = [(x, y) | x <- l1, y <-l2]
f l1 l2 = do
    x <- l1
    y <- l2
    return (x, y)

More monads

f l1 l2 = do
    x <- l1
    y <- l2
    return $ x + y

f readLine readLine
f (Just 3) (Just 4)
f (Just 3) Nothing

• containers
  • Maybe a : at most one value of type a
  • [a] : several values of type a
• actions
  • IO a : action with result of type a and some side-effects
  • STM a : subset of IO a for paralellism
• others
  • State, Reader, Writer, Parsec, etc

First window

import Graphics.Rendering.Cairo
import Graphics.UI.Gtk

main = do
  initGUI
  window <- windowNew
  widgetShowAll window
  mainGUI

• closing the window doesn't terminate the application

Closing the window

import Graphics.Rendering.Cairo
import Graphics.UI.Gtk

main = do
  initGUI
  window <- windowNew
  window `on` deleteEvent $ liftIO mainQuit >> return False
  widgetShowAll window
  mainGUI

• GTK works with signals and events
  • user generates an event
  • GTK sends a signal to the window
• on connects a function to a signal
• mainQuit will signal GTK to close everything
• deleteEvent expects a Bool value

Window details

import Graphics.Rendering.Cairo
import Graphics.UI.Gtk

main = do
  initGUI
  window <- windowNew
  window `on` deleteEvent $ liftIO mainQuit >> return False
  windowSetGeometryHints window (Nothing :: Maybe Window)
    (Just (800, 600)) (Just (800, 600)) Nothing Nothing Nothing
  set window [ windowTitle := "First GUI app" ]
  widgetShowAll window
  mainGUI

• Too many functions to remember, too many parameters
• Help is on the way
  • Hoogle: http://www.haskell.org/hoogle/
• Now we can code an entire GUI application
  • Code!

FRP

• imperative GUI
• functional one?
• Functional Reactive Programming
  • describe system in terms of time varying functions instead of state
  • specify dynamic behaviour of values at time of declaration
• research area

counter :: Behavior Int
counter = accumulate ($) 0
            (fmap (+1) eventUp
             `union` fmap (subtract 1) eventDown)

End