- GuiElems
- Combinators
- InfixOps
- Layout
- Containers
- StreamProc
- InOut
- LowLevel
- Types
- FudUtilities
- Debug
- ContribFudgets

- Audio:
bellF :: F

`ho``ho`- Buttons:
**data**Click = ...buttonF :: (Graphic

`lbl`) =>`lbl`-> F Click ClickradioGroupF :: (Eq

`alt`, Graphic`lbl`) => [(`alt`,`lbl`)] ->`alt`-> F`alt``alt`toggleButtonF :: (Graphic

`lbl`) =>`lbl`-> F Bool Bool- Data entry fields:
intInputF :: F Int Int

passwdInputF :: F String String

stringInputF :: F String String

- Decoration:
labAboveF :: (Graphic

`p`) =>`p`-> F`c``d`-> F`c``d`labBelowF :: (Graphic

`p`) =>`p`-> F`c``d`-> F`c``d`labLeftOfF :: (Graphic

`p`) =>`p`-> F`c``d`-> F`c``d`labRightOfF :: (Graphic

`p`) =>`p`-> F`c``d`-> F`c``d`labelF :: (Graphic

`g`) =>`g`-> F`a``b`- 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

`g`) => F`g``void`intDispF :: F Int

`b`- Menus:
menuF :: (Graphic

`mlbl`, Graphic`albl`) =>`mlbl`-> [(`alt`,`albl`)] -> F`alt``alt`popupMenuF :: (Graphic

`b1`, Eq`b1`) => [(`a`,`b1`)] -> F`c``b2`-> F ([(`a`,`b1`)] ⊕`c`) (`a`⊕`b2`)- Pop-up windows:
**data**ConfirmMsg = ...confirmPopupF :: (Graphic

`msg`) => F`msg`(`msg`, ConfirmMsg)messagePopupF :: (Graphic

`msg`) => F`msg`(`msg`, 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

`ans``ho`

- Abstract fudgets: from stream processors:
absF :: SP

`a``b`-> F`a``b`- Abstract fudgets: stateful:
mapstateF :: (

`t`->`a`-> (`t`, [`b`])) ->`t`-> F`a``b`- 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 (

`a`⊕`b`) (`a`⊕`c`) -> F`b``c`loopOnlyF :: F

`a``a`-> F`a``b`loopRightF :: F (

`a`⊕`b`) (`c`⊕`b`) -> F`a``c`loopThroughRightF :: F (

`a`⊕`b`) (`c`⊕`d`) -> F`c``a`-> F`b``d`- Plumbing: serial composition:
serCompF :: F

`a1``b`-> F`a2``a1`-> F`a2``b`- Plumbing: tagged parallel composition:
compF :: F

`a``b`-> F`c``d`-> F (`a`⊕`c`) (`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`hi``ho`= ...- The identity fudget:
idF :: F

`b``b`

- Plumbing: serial composition:
>==< :: F

`a1``b`-> F`a2``a1`-> F`a2``b`- Plumbing: tagged parallel composition:
>+< :: F

`a``b`-> F`c``d`-> F (`a`⊕`c`) (`b`⊕`d`)- Plumbing: untagged parallel composition:
>*< :: F

`c``ho`-> F`c``ho`-> F`c``ho`

- 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 = IntmarginS :: Distance -> Spacer

- Scroll bars:
hScrollF :: F

`b``d`-> F`b``d`scrollF :: F

`b``d`-> F`b``d`vScrollF :: F

`b``d`-> F`b``d`- Shell (top level) windows:
shellF :: String -> F

`c``d`-> F`c``d`

- Stream processor equivalents of some common list processing functions:
chopSP :: ((

`b`-> SP`a``b`) -> SP`a``b`) -> SP`a``b`concatMapAccumlSP :: (

`t`->`a`-> (`t`, [`b`])) ->`t`-> SP`a``b`concatMapSP :: (

`t`-> [`b`]) -> SP`t``b`concatSP :: SP [

`b`]`b`filterSP :: (

`b`-> Bool) -> SP`b``b`idSP :: SP

`b``b`mapAccumlSP :: (

`t`->`a`-> (`t`,`b`)) ->`t`-> SP`a``b`mapSP :: (

`t`->`b`) -> SP`t``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, IOError ⊕ [String])

readFileF :: F String (String, IOError ⊕ String)

writeFileF :: F (String, String) (String, IOError ⊕ ())

- The combinator that connects the main fudget to the Haskell I/O system:
fudlogue :: F

`a``b`-> IO ()

- Buttons:
**data**Click = ...- Pop-up windows:
**data**ConfirmMsg = ...- The Fudget type:
**data**F`hi``ho`= ...**type**FCommand`a`= Message TCommand`a`**type**FEvent`a`= Message TEvent`a`**type**FSP`hi``ho`= SP (FEvent`hi`) (FCommand`ho`)**type**Fudget`a``b`= F`a``b`**type**TCommand = (Path, FRequest)**type**TEvent = (Path, FResponse)- The type of plain stream processors:
**data**SP`a``b`= ...

- Various utility functions for pairs and lists:
aboth :: (

`t`->`b`) -> (`t`,`t`) -> (`b`,`b`)anth :: Int -> (

`a`->`a`) -> [`a`] -> [`a`]gmap :: (Foldable

`t1`) => (`t2`-> [`a`] -> [`a`]) -> (`t3`->`t2`) ->`t1``t3`-> [`a`]issubset :: (Eq

`a`, Foldable`t2`, Foldable`t1`) =>`t1``a`->`t2``a`-> Boollhead :: [

`a1`] -> [`a2`] -> [`a2`]loop :: (

`t`->`t`) ->`t`lsplit :: [

`a1`] -> [`a2`] -> ([`a2`], [`a2`])ltail :: [

`a1`] -> [`a2`] -> [`a2`]mapPair :: (

`t1`->`a`,`t2`->`b`) -> (`t1`,`t2`) -> (`a`,`b`)number :: Int -> [

`a`] -> [(Int,`a`)]oo :: (

`t1`->`t2`) -> (`t3`->`t4`->`t1`) ->`t3`->`t4`->`t2`pair ::

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

`t`->`b`) ->`t`-> (`t`,`b`)part :: (

`a`-> Bool) -> [`a`] -> ([`a`], [`a`])remove :: (Eq

`t`) =>`t`-> [`t`] -> [`t`]replace :: (Eq

`a`) => (`a`,`b`) -> [(`a`,`b`)] -> [(`a`,`b`)]swap :: (

`b`,`a`) -> (`a`,`b`)unionmap :: (Eq

`a`, Foldable`t1`) => (`t2`-> [`a`]) ->`t1``t2`-> [`a`]

- A fudget that shows the high level input and output of a fudget on the standard error output:
spyF :: (Show

`a2`, Show`b`) => F`a2``b`-> F`a2``b`- An identity fudget that copies messages to the standard error output:
teeF :: (

`b`-> [Char]) -> [Char] -> F`b``b`

- Menus:
menuF :: (Eq

`a`) => Menu`a`-> F`a``a`