¤ Fudget Library Reference Manual ¤
Created from the Fudget Library sources on Sat Jun 24 16:22:22 CEST 2000
Beginner's Index
Sections
 Audio:

bellF :: F a a
 Buttons:

data Click = ...

buttonF :: (Graphic a) => a > F Click Click

radioGroupF :: (Graphic b, Eq a) => [(a, b)] > a > F a a

toggleButtonF :: (Graphic a) => a > F Bool Bool
 Data entry fields:

intInputF :: F Int Int

passwdInputF :: F String String

stringInputF :: F String String
 Decoration:

labAboveF :: (Graphic a) => a > F b c > F b c

labBelowF :: (Graphic a) => a > F b c > F b c

labLeftOfF :: (Graphic a) => a > F b c > F b c

labRightOfF :: (Graphic a) => a > F b c > F b c

labelF :: (Graphic a) => a > F b c
 Displaying and interacting with lists:

type PickListRequest a = ListRequest a

pickListF :: (a > String) > F (PickListRequest a) (InputMsg (Int, a))
 Displaying text:

moreF :: F [String] (InputMsg (Int, String))

moreFileF :: F String (InputMsg (Int, String))

moreFileShellF :: F String (InputMsg (Int, String))

moreShellF :: String > F [String] (InputMsg (Int, String))
 Displays:

displayF :: (Graphic a) => F a b

intDispF :: F Int a
 Menus:

menuF :: (Graphic a, Graphic c) => a > [(b, c)] > F b b

popupMenuF :: (Graphic b, Eq b) => [(a, b)] > F c d > F (Either [(a, b)] c) (Either a d)
 Popup windows:

data ConfirmMsg = ...

confirmPopupF :: (Graphic a) => F a (a, ConfirmMsg)

messagePopupF :: (Graphic a) => F a (a, Click)

passwdPopupF :: String > F (Maybe String, Maybe String) ((Maybe String, Maybe String), String)

stringPopupF :: String > F (Maybe String, Maybe String) ((Maybe String, Maybe String), String)
 Terminating the program:

quitF :: F a b
 Abstract fudgets: from stream processors:

absF :: SP a b > F a b
 Abstract fudgets: stateful:

mapstateF :: (a > b > (a, [c])) > a > F b c
 Abstract fudgets: stateless:

concatMapF :: (a > [b]) > F a b

mapF :: (a > b) > F a b
 Plumbing: circular connections:

loopF :: F a a > F a a

loopLeftF :: F (Either a b) (Either a c) > F b c

loopOnlyF :: F a a > F a b

loopRightF :: F (Either a b) (Either c b) > F a c

loopThroughRightF :: F (Either a b) (Either c d) > F c a > F b d
 Plumbing: serial composition:

serCompF :: F a b > F c a > F c b
 Plumbing: tagged parallel composition:

compF :: F a b > F c d > F (Either a c) (Either b d)

listF :: (Eq a) => [(a, F b c)] > F (a, b) (a, c)
 Plumbing: untagged parallel composition:

untaggedListF :: [F a b] > F a b
 The Fudget type:

data F a b
 The identity fudget:

idF :: F a a
 Plumbing: serial composition:

infixr 4 >==<

>==< :: F a b > F c a > F c b
 Plumbing: tagged parallel composition:

infixl 5 >+<

>+< :: F a b > F c d > F (Either a c) (Either b d)
 Plumbing: untagged parallel composition:

infixl 5 >*<

>*< :: F a b > F a b > F a b
 A spacer that centers a box in the available space:

centerS :: Spacer
 GUI fudget placement:

data Placer = ...

placerF :: Placer > F a b > F a b
 GUI fudget spacing:

data Spacer = ...

spacerF :: Spacer > F a b > F a b
 Placer modifying combinators:

flipP :: Placer > Placer

revP :: Placer > Placer
 Placers for creating matrixes:

matrixP :: Int > Placer
 Placers for creating tables:

tableP :: Int > Placer
 Placers for vertical and horizontal placement:

horizontalP :: Placer

verticalP :: Placer
 Spacers that add margins to boxes:

type Distance = Int

marginS :: Distance > Spacer
 Scroll bars:

hScrollF :: F a b > F a b

scrollF :: F a b > F a b

vScrollF :: F a b > F a b
 Shell (top level) windows:

shellF :: String > F a b > F a b
 Stream processor equivalents of some common list processing functions:

chopSP :: ((a > SP b a) > SP b a) > SP b a

concatMapAccumlSP :: (a > b > (a, [c])) > a > SP b c

concatMapSP :: (a > [b]) > SP a b

concatSP :: SP [a] a

filterSP :: (a > Bool) > SP a a

idSP :: SP a a

mapAccumlSP :: (a > b > (a, c)) > a > SP b c

mapSP :: (a > b) > SP a b

splitAtElemSP :: (a > Bool) > Cont (SP a b) [a]

zipSP :: [a] > SP b (a, b)
 The type of plain stream processors:

data SP a b
 A fudget that outputs ticks after specific delays and/or at specific intervals:

data Tick = ...

timerF :: F (Maybe (Int, Int)) Tick
 File system access:

readDirF :: F String (String, Either D_IOError [String])

readFileF :: F String (String, Either D_IOError String)

writeFileF :: F (String, String) (String, Either D_IOError ())
 The combinator that connects the main fudget to the Haskell I/O system:

fudlogue :: F a b > IO ()
 The Fudget type:

type TEvent = (Path, FResponse)

type TCommand = (Path, FRequest)

type FEvent a = Message TEvent a

type FCommand a = Message TCommand a

type Fudget a b = F a b

type FSP a b = SP (FEvent a) (FCommand b)

data F a b = ...
 The type of plain stream processors:

data SP a b
 Various utility functions for pairs and lists:

aboth :: (a > b) > (a, a) > (b, b)

anth :: Int > (a > a) > [a] > [a]

gmap :: (a > [b] > [b]) > (c > a) > [c] > [b]

issubset :: (Eq a) => [a] > [a] > Bool

lhead :: [a] > [b] > [b]

loop :: (a > a) > a

lsplit :: [a] > [b] > ([b], [b])

ltail :: [a] > [b] > [b]

mapPair :: (a > b, c > d) > (a, c) > (b, d)

number :: Int > [a] > [(Int, a)]

oo :: (a > b) > (c > d > a) > c > d > b

pair :: a > b > (a, b)

pairwith :: (a > b) > a > (a, b)

part :: (a > Bool) > [a] > ([a], [a])

remove :: (Eq a) => a > [a] > [a]

replace :: (Eq a) => (a, b) > [(a, b)] > [(a, b)]

swap :: (a, b) > (b, a)

unionmap :: (Eq b) => (a > [b]) > [a] > [b]
 A fudget that shows the high level input and output of a fudget on the standard error output:

spyF :: (Show b, Show a) => F a b > F a b
 An identity fudget that copies messages to the standard error output:

teeF :: (a > [Char]) > [Char] > F a a
 Menus:

menuF :: (Eq a) => Menu a > F a a