TV is a library for composing tangible values ("TVs"), i.e., values that carry along external interfaces. In particular, TVs can be composed to create new TVs, and they can be directly executed with a friendly GUI, a process that reads and writes character streams, or many other kinds interfaces. Values and interfaces are combined for direct use, and separable for composition.
TV is for creating software that is ready to use and ready to reuse.
Beside this page, here are some ways to explore TV:
- Read the Haddock docs (with source code, additional examples, and Comment/Talk links)
- Get the code repository: darcs get http://darcs.haskell.org/packages/TV
- Or grab a distribution tarball.
2 Tangible values
As a first example, here is a tangible reverse function:
reverseT :: CTV (String -> String) reverseT = tv (oTitle "reverse" defaultOut) reverse
runUI reverseT runIO reverseT *Examples> runIO reverseT reverse: Hello, reversible world. .dlrow elbisrever ,olleH *Examples>
2.1 OutputsWhat I've been calling an "interface" is a value of type
total :: Show a => COutput a total = oTitle "total" showOut
2.2 Inputs and function-valued outputs
Just as an output is a way to deliver a value, an "input" is a way to obtain a value. For example, here are two inputs, each specifying an initial value and a value range, and each given a title.
apples, bananas :: CInput Int apples = iTitle "apples" defaultIn bananas = iTitle "bananas" defaultIn
shoppingO :: COutput (Int -> Int -> Int) shoppingO = oTitle "shopping list" $ oLambda apples (oLambda bananas total)
And a TV:
shopping :: CTV (Int -> Int -> Int) shopping = tv shoppingO (+)
2.3 A variation
Here is an uncurried variation:
shoppingPr :: CTV ((Int,Int) -> Int) shoppingPr = tv ( oTitle "shopping list -- uncurried" $ oLambda (iPair apples bananas) total ) (uncurry (+))
shoppingPr = uncurryA $$ shopping
2.4 The general story
TVs, outputs and inputs are not restricted to GUIs and IO. In general, theyre parameterized by an arrow.
data Output (~>) a data Input (~>) a type TV (~>) a
type KIO = Kleisli IO
2.5 Common Ins and OutsThe examples
type Common f a = forall (~>). CommonInsOuts (~>) => f (~>) a
type CInput a = Common Input a type COutput a = Common Output a type CTV a = Common TV a
2.6 Sorting examples
Here's a sorting TV:
sortT :: (Read a, Show a, Ord a) => CTV ([a] -> [a]) sortT = tv (oTitle "sort" $ interactRSOut ) sort
2.7 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.First, wrap up the
wordsT :: CTV (String -> [String]) wordsT = tv ( oTitle "function: words" $ oLambda (iTitle "sentence in" defaultIn) (oTitle "words out" defaultOut)) words
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
The operator "<div class="inline-code">
runUI sortWordsT runIO sortWordsT *Examples> runIO sortWordsT sentence in: The night Max wore his wolf suit sentence out: Max The his night suit wolf wore
2.8 Arrow-specific interfaces
While some interfaces can be implemented for different kinds of interfaces, others are more specialized.
Here are inputs for our shopping example above that specifically work with Phooey's UI arrow.
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:
2.8.2 IOWe can use
interactOut :: Output KIO (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 KIO (String -> String) testO = oLambda (fileIn "test.txt") defaultOut
wrapF :: (c->d) -> (a->b) -> ((b->c) -> (a->d)) wrapF after before f = after . f . before
onLines, onWords :: ([String] -> [String]) -> (String -> String) onLines = wrapF unlines lines onWords = wrapF unwords words
io3 = tv testO (onLines reverse) io4 = tv testO (onWords reverse)