Tangible Value

shoppingPr = uncurryA $$ shopping

Running:

runUI shoppingPr	runIO shoppingPr
	shopping list: apples: 8 bananas: 5 total: 13

6 The general story

TVs, outputs, and inputs are not restricted to GUIs and IO. In general, they are parameterized by the mechanics of "transmitting values", i.e., delivering ("sinking") output and gathering ("sourcing") input.

data Input  src     a
data Output src snk a
type TV     src snk a

The "sources" will be applicative functors (AFs), and the "sinks" will be cofunctors.

runUI :: TV UI IU a -> IO ()
runUI = runTV
 
runIO :: TV IO OI a -> IO ()
runIO = runTV

7 Common Ins and Outs

type CInput a = forall src.
  (CommonIns src)                 => Input  src     a
type COutput a = forall src snk.
  (CommonIns src, CommonOuts snk) => Output src snk a
type CTV a = forall src snk.
  (CommonIns src, CommonOuts snk) => TV     src snk a

8 Sorting examples

sortT :: (Read a, Show a, Ord a) => CTV ([a] -> [a]) sortT = tv (oTitle "sort" $ interactLinesRS []) sort

runUI (sortT :: CTV ([String] -> [String]))

9 Composition of TVs

So far, we done a little composition of interfaces and combined them with values to construct TVs. Now let's look at composition of TVs.

unwordsT :: CTV ([String] -> String) unwordsT = tv ( oTitle "function: unwords" $ oLambda (iTitle "words in" defaultIn) (oTitle "sentence out" defaultOut)) unwords

unwordsT :: CTV ([String] -> String) unwordsT = tv ( oTitle "function: unwords" $ oLambda (iTitle "words in" defaultIn) (oTitle "sentence out" defaultOut)) unwords

sortWordsT :: CTV (String -> String)
sortWordsT = wordsT ->| sortT ->| unwordsT

Running:

runUI sortWordsT	runIO sortWordsT
	sentence in: The night Max wore his wolf suit sentence out: Max The his night suit wolf wore

10 Transmission-specific interfaces

While some interfaces can be implemented for different means of transmission, others are more specialized.

10.1 GUIs

Here are inputs for our shopping example above that specifically work with Phooey's UI applicative functor.

applesU, bananasU :: Input UI Int
applesU  = iTitle "apples"  (islider 3 (0,10))
bananasU = iTitle "bananas" (islider 7 (0,10))
 
shoppingUO :: Output UI (Int -> Int -> Int)
shoppingUO = oTitle "shopping list" $ oLambda applesU (oLambda bananasU total)

We can then make curried and uncurried TVs:

code	runUI rendering
tv shoppingUO (+)
uncurryA $$ tv shoppingUO (+)

10.2 IO

interactOut :: Output IO OI (String -> String)
interactOut = oLambda contentsIn stringOut

Assuming we have a file "test.txt" containing some lines of text, we can use it to test string transformations.

testO :: Output IO OI (String -> String)
testO = oLambda (fileIn "test.txt") defaultOut

First, let's define higher-order functions that apply another function to the lines or on the words of a string.

onLines, onWords :: ([String] -> [String]) -> (String -> String)
onLines f = unlines . f . lines
onWords f = unwords . f . words

Next, specializations that operate on each line or word:

perLine,perWord :: (String -> String) -> (String -> String)
perLine f = onLines (map f)
perWord f = onWords (map f)

Some examples:

string function f	runIO (tv test0 f)
id	To see a World in a Grain of Sand And a Heaven in a Wild Flower, Hold Infinity in the palm of your hand And Eternity in an hour. - William Blake
reverse	ekalB mailliW - .ruoh na ni ytinretE dnA dnah ruoy fo mlap eht ni ytinifnI dloH ,rewolF dliW a ni nevaeH a dnA dnaS fo niarG a ni dlroW a ees oT
onLines reverse	- William Blake And Eternity in an hour. Hold Infinity in the palm of your hand And a Heaven in a Wild Flower, To see a World in a Grain of Sand
perLine reverse	dnaS fo niarG a ni dlroW a ees oT ,rewolF dliW a ni nevaeH a dnA dnah ruoy fo mlap eht ni ytinifnI dloH .ruoh na ni ytinretE dnA ekalB mailliW -
perLine (perWord reverse)	oT ees a dlroW ni a niarG fo dnaS dnA a nevaeH ni a dliW ,rewolF dloH ytinifnI ni eht mlap fo ruoy dnah dnA ytinretE ni na .ruoh - mailliW ekalB

There are more examples in the TV repository and in the in the GuiTV repository. See also "separating IO from logic -- example".

Categories: Interfaces | IO | Arrow | Libraries | Packages