Difference between revisions of "LGtk"
Line 149: | Line 149: | ||
Is there a state with a well-behaved extend function? |
Is there a state with a well-behaved extend function? |
||
− | The answer is '''yes''', but we should guarantee linear usage of the state. This is great, because linear usage is guaranteed |
+ | The answer is '''yes''', but we should guarantee linear usage of the state. This is great, because linear usage is guaranteed with the restricted API! |
How can such an <hask>S</hask> be implemented? And how can such an <hask>S</hask> be implemented efficiently? These questions are not relevant for the semantics, but there is an efficient implementation with <hask>IORef</hask>s. |
How can such an <hask>S</hask> be implemented? And how can such an <hask>S</hask> be implemented efficiently? These questions are not relevant for the semantics, but there is an efficient implementation with <hask>IORef</hask>s. |
Revision as of 13:36, 2 June 2013
What is it?
LGtk is a lens-based API for Gtk. LGtk is built on Gtk2Hs.
Most Haskellers would like to use a mature FRP-based API for creating graphical user interfaces. FRP may not be the best tool for special user interfaces, like interfaces which consists of buttons, checkboxes, combo boxes, text entries and menus only. LGtk has a lens-based API which fits better these user interfaces.
Semantics overview
The semantics of LGtk is given by a reference implementation. The reference implementation is given in the following stages.
Lenses
LGtk use simple lenses defined in the data-lens package:
newtype Lens a b = Lens { runLens :: a -> Store b a }
This data type is isomorphic to (a -> b, b -> a -> a)
, the well-know lens data type. The isomorphism is established by the following operations:
getL :: Lens a b -> a -> b
setL :: Lens a b -> b -> a -> a
lens :: (a -> b) -> (b -> a -> a) -> Lens a b
Lens laws
The three well-known laws for lenses:
- get-set:
set k (get k a) a
===a
- set-get:
get k (set k b a)
===b
- set-set:
set k b2 (set k b1 a)
===set k b2 a
Impure lenses, i.e. lenses which brake lens laws are allowed in certain places. Those places are explicitly marked and explained in this overview.
References
It is convenient to use lenses with the state monad (see this use case) and the reader monad.
Let's call a value with type Lens s a
a reference of the state monad State s
and the reader monad Reader s
.
References are distinguished from lenses, because we would like to make the program state s
unaccessible to guarantee linear use of the state for example.
There are several ways to model references in Haskell. LGtk models them as type classes with associated types, but that is just a technical detail.
Types
Instead of giving a concrete implementation in Haskell, suppose that
s
is a fixed type,Ref :: * -> *
~Lens s
, references are lenses froms
to the type of the referred value,R :: * -> *
~Reader s
, the reference reading monad is the reader monad overs
,S :: * -> *
~State s
, the reference reading and writing monad is the state monad overs
.
The three equality constraints are not exposed in the API.
Operations
Exposed operations of Ref
, S
and R
:
- The
Monad
instance ofS
andR
- The monad morphism between
R
andS
liftReadPart :: R a -> S a
liftReadPart = gets . runReader
- Reference read
readRef :: Ref a -> R a
readRef = reader . getL
- Reference write
writeRef :: Ref a -> a -> S ()
writeRef = modify . setL r
- Lens application on a reference
lensMap :: Lens a b -> Ref a -> Ref b
lensMap = (.)
- Reference join
joinRef :: R (Ref a) -> Ref a
joinRef = Lens . join . (runLens .) . runReader
- The unit reference
unitRef :: Ref ()
unitRef = lens (const ()) (const id)
Note that the identity lens is not a reference because that would leak the program state s
.
Reference creation
There should be a possibility for new reference creation too.
New reference creation with a given initial value extends the state. For example, if the state is (1, 'c') :: (Int, Char)
, extending the state with True :: Bool
would yield the state ((1, 'c'), True) :: ((Int, Char), Bool)
.
We could model the type change of the state with an indexed monad, but that would complicate both the API and the implementation too.
Instead of changing the type of the state, we use an extensible state, a data type S
with the operations
empty :: S
extend :: a -> State S (Lens S a)
such that the following laws hold:
extend v >> return ()
===return ()
extend v >>= liftReadPart . readRef
===return v
The first law sais that extend
has no side-effect, i.e. extending the state does not change the values of existing references.
The second law sais that extending the state with value v
creates a reference with inital value v
.
Is there a state with a well-behaved extend function?
The answer is yes, but we should guarantee linear usage of the state. This is great, because linear usage is guaranteed with the restricted API!
How can such an S
be implemented? And how can such an S
be implemented efficiently? These questions are not relevant for the semantics, but there is an efficient implementation with IORef
s.
Reference creation API
Let S
be an extensible state as specified before.
Let s
= S
in the definition of references.
C :: (* -> *) -> * -> *
~StateT S
The equality constraint is not exposed in the API. The following functions are exposed:
- New reference creation
newRef :: Monad m => a -> C m (Ref a)
newRef v = mapStateT (return . runIdentity) $ extend v
- Lift reference read and write operations
liftWrite :: Monad m => S a -> C m a
liftWrite = mapStateT (return . runIdentity)
- Derived
MonadTrans
instance ofC
to be able to lift operations in them
monad.
Note that C
is parameterized by a monad because in this way it is easier to add other effects later.
Running
The last missing function in the API is the running of the C m
monad.
- Run the reference creation monad
runC :: Monad m => C m a -> m a
runC x = runStateT x empty
Lens-trees
TODO
Effects
TODO
Examples
Hello World
main = runWidget $ label $ return "Hello World!"
return
is neded because labels may be dynamic, see the next examples.
Copy
The following applications presents an entry and a label below of it. When a text is entered in the entry, the label is changed to the entered text.
main = runWidget $ action $ do
r <- newRef "enter text here"
return $ vcat
[ entry r
, label $ readRef r
]
action
gives acces to a monad in which new references can be made by newRef
.
A crutial feature of LGtk is that you cannot change the value of references in this monad (you can read them though).
label
gives acces to a monad in which you can read references but no reference creation or write is possible.
Addition
Two entries of integers and a label which shows the sum:
main = runWidget $ action $ do
r1 <- newRef (12 :: Integer)
r2 <- newRef 4
return $ vcat
[ entryShow r1
, entryShow r2
, label $ liftM show $ liftM2 (+) (readRef r1) (readRef r2)
]
Complex examples
You can find more complex examples in the source code of LGtk. More examples will be presented here also.
Status
Features of lgtk-0.5
- The API is closed, you can safely use any constructs as far as you obey the documented laws.
- Support for asynchronous events. Using LGtk is a safe way for writing multithreaded Gtk applications.
- The semantics is getting stable but it is not yet documented.
TODO list:
- Add an efficient implementation for LGtk. LGtk has only a reference implementation currently.
- Add support for styles (layout, colors, etc).
- Support more Gtk constructs.
Demo application
You can try the demo application with the following commands:
cabal install gtk2hs-buildtools cabal install lgtk lgtkdemo
Changelog
lgtk-0.5.1
- Documentation fixes and cleanup
- Try to support Haskell Platform 2012.4.0.0
lgtk-0.5
- Do not use monadic lenses any more.
- Support for asynchronous events.
- Lazily created tabs.
- Unactive tabs are really unactive (event handlers are detached).
- File references watch the files. When the file changes, the GUI is updated.
- References with inherent identity (makes defining auto-sensitive buttons easier)
- Experimental support for colored buttons.
- More examples in the demo application.
- Lots of inner changes.
External links
Related Stackoverflow questions:
Reddit comments: