A monad for reactive programming Part 2

Some time has passed since I published the first part of this tutorial. The time has been spent in achieving a deeper understanding of events and event processing. In this second part I solve the problems of the simple approach depicted at the end of the part 1.

The motivating example to solve is the same, a console application with a basic event scheduler, a monadic computation that has some statements which wait for different kinds of events. You can run the two examples here in the tutorial.

This tutorial also can be considered as the description of an event sourcing mechanism without inversion of control. A event sourcing application is basically a set of event handlers for each type of event with a central state. A functional reactive mechanism is a single event handler with event preprocessing on top. while a monadic reactive mechanism like this is a monadic computation that automatically generates a cascade of event handlers.

Besides monadic reactive, I will demonstrate more classical functional reactive behaviour using applicative combinators, and how to mix monadic, reactive and alternative to mimic the creation of new signals with thresholds etc.

The tutorial and running examples are in the School of Haskell

Browser programming: React.js as a solution for a problem that Haskell can solve in better ways

This is what i wrote in this Reddit thread.

IMHO virtual-dom as well as React tries to solve a problem specific of javascript: the lack of a intuitive, composable way to update the HTML-DOM tree. So it creates a composable intermediary, a lineal virtual-dom. Basically, it is string concatenation. When changed, the intermediary lineal description is rendered. But the rewrites and re-rendering are expensive, so they need to update only what is changed.

That problem disappears when there is a way to write directly the HTML-DOM in a composable way, using a monoid or a monad. Then, to rewrite any branch, just go to the element and update it also in a composable way. That is what I want to detail below:

Basically, both virtual-dom and react use intermediary lineal images of the dom just to be able to do this:

div [atribute "width" 100] $ ("hello") <> div [attribute "height" 200] "whathever"

Since strings are composable in javascript as well as in any language. But trees are not.

That composable syntax is impossible in javascript with the HTML DOM directly.

But Haskell has a lot more tricks. It is possible to compose functions as monoids. these functions may be builders of DOM elements. these builder functions create dom elements, attributes etc using DOM primitives inside.

That is what ahem.... what my perch library does.

https://github.com/agocorona/haste-perch

It updates directly the HTML-DOM in a composable way as if they were blaze-html elements IN the browser:

div $ do

   div ! atr "width" "100"  $ "hello" 

   div ! atr "height" 200 $ "whathever"

and so on. div here is a builder function. it can be composed this way, monadically or with a monoid syntax. Both are equivalent, like in the case of the blaze-html library. but while blaze-html concatenate strings, perch concatenate builder functions that create trees. In the above example, in creates a div node with two more divs inside.

Do you want to update an element? modify it directly. Since it does not update an intermediary description, there is no need to detect differences in the intermediate description to avoid to render again the whole description. It simply does it in the DOM.

forElems ".classtochange" $ this ! width "300" ! atr "class" "changed"

The above expression is similar to a jquery modification. it is applied for all the elements that match.

in lineal descriptions like the ones of virtual-dom or react each element is not directly addressable. To address the elements is as expensive as to sequentially rewrite the description with a new one. The need to detect differences is then a consequence of a lineal description. And the lineal description a consequence of the need of composability.

But a set of monoidal combinators of functions that update the DOM are composable . And it is pure Haskell, no need to use Javascript libraries.

Usage in Reactive Frameworks

I have to say that the virtual-DOM-React approach is ideal for functional reactive frameworks like Elm and others, since them manage the page as a whole. Every signal may change the whole page. I´m not an expert and my knowledge of this is far from accurate, but it seems to me that there are no event scopes, since the events feed a single entry point that re-render the whole page, as far as I know. Or alternatively they modify placeholders in a static template. Without React , Elm and all the functional reactive frameworks were limited to the second option. With it, they can perform more dynamic DOM effects. without React, it was hard to create a responsive TODO application in a functional reactive framework.

Monadic functional reactive may be more promising, since the events can be catched and managed locally (and the DOM updates are local too) they don't affect the whole computation and the re-rendering of the entire page. As the paper is the Google search says: "In other (non monadic) FRP approaches, either the entire FRP expression is re-evaluated on each external stimulus, or impure techniques are used to prevent redundant re-computations". That is the problem that Monadic Reactive solves.

I don´t know how to to slip here hplayground which is a monadic functional reactive framework for Browser applications. For this framework, Perch is perfect. But also is fine as such, with event handlers managed by perch itself.

Haskell running in the #cordovajp phonegap framework for hybrid smartphone applications.

#Haskell running in the #cordovajp phonegap framework for hybrid smartphone applications. Details soon #javascript pic.twitter.com/toKsSKnZ8r
— Alberto G. Corona (@AGoCorona) November 13, 2014

The source code and the instructions are here





The code has been put in another place avoid the disastrous and ever embarrassing formatting nightmares of Blogger.com, that does whatever it wants with my posts, that convert copying and pasting into a horror film, every keystroke is an adventure, any innocent tag insertion into a Derridian deconstruction, whose matches of his previews with the reality are pure coincidence.

Mi vision for a single high level language for the web and the cloud

The question of either to write code server side or browser side is more than a question, it is a problem. Either way, you will end up rewriting code from one side to the other because you suddenly will realize that to add something to that functionality in the server, you need something from the client and vice versa, after some changes you will realize that your functionality in the client would run better in the server or the other way around, so you will rewrite code back and forth from the server to the client and viceversa.

The underlying problem

The underlying problem is the lack of a  high level language both for the Web and the cloud, that can run in the server and in the browser, so that no code rewrite is necessary for communication locally or remotely, so each piece of functionality can be migrated at installation time depending on the capabilities of each node. Or.. better, at runtime, depending on capabilities and load conditions, from the server to the client and back. It can be done. It is something that I have been after since I started coding Web applications. First I tried it to design such a system with javascript, but at that time nothing in the Web architecture were mature enough.

The Web

MFlow and hplayground are a server and a client haskell Web frameworks respectively. Both share the same syntax and semantics, that is, almost the same code for the creation of pages and for the creation of dynamic effects in them. MFlow can perform almost all the page dynamic effects with or without ajax and javascript, using full page refresh when AJAX is not available .  Hplayground can perform richer reactive, dynamic effects since all the code has been compiled to javascript.

In my roadmap I plan to create a hplayground module for MFlow, with a single modifier, call it "client", that will compile the MFlow code to javascript using hplayground libraries and will run it in the browser. Otherwise it will behave as any other MFlow page procedure. Later that process of segregation will be automated; There will be no "client" modifier and any presentation code can be translated to javascript and can run in the browser, depending on the capabilities of the browser, load conditions, bandwidth etc.

Cloud:

MFlow has the FlowM monad, that can perform tracking, backtracking and long running transactions.  See this article:

How Haskell can solve the integration problem - FP Complete

These effecta are very important for the creation of loosely coupled architectures where exceptional conditions are not only exceptional, they also may be a part of the flow.  Conceptually a web application is a loosely coupled application with a server and a browser, where the client interrupt and send requests and responses in any order. To deal with that, the FlowM monad has these tracking, backtracking and state management effects. These are the very same effects necessary for dealing with communication failures, error conditions or transaction rollbacks from other MFlow nodes and/or databases without resorting to the spaghetti code of event handlers and a centralized updated state. Like in the case of web frameworks,  spaghetization precludes the programming of cloud framework such is Cloud Haskell at a higher level.

In my roadmap is the creation of MFlow node communication for synchronization and inter-node data access, using the web first, and later cloud Haskell as communication means, so that clusters of MFlow nodes share the processing load and the data access load. At the end all the cloud distribution of resources will start in a single program in a single node. The distribution of data and procedures will be automatic. I will add a "remote" modifier to distribute MFlow procedures. Later this remote modifier will disappear and it will be automatic, just like in the case of the "client" modifier for the browser. But this time these application would not be focused in web applications but any kind of them.

This may sound too ambitious. In fact that was never my goal, but a goal of the developer community. I always found it desirable and realizable, but not by me alone. However I  never imagined that I would realize it to the level that I've already done. I ever thought that this  would be done by other people. 

Who knows maybe I can see it realized. Maybe I find more people to join this vision. God will say.

UPDATE 03/09/2015  instead of cloud haskell, I developped my own distributed architecture, that is higher level; Transient:

http://github.com/agocorona/transient

Transient is based on the hplaygroud monad for handling events reactively. An event can be a mouse click, but also the arrival of data through a socket.  The MFlow web server and and navigation can be implemented on top of that so the dream is closer to reality.

Spreadsheet-like program in the browser using loeb iteration and loop resolution

I finally did what I was trying to do: to add full spreadsheet like effects to hplayground the haskell-javascript framework that uses the haste compiler

See the example running:

http://tryplayg.herokuapp.com/try/spreadsheet.hs/edit

I used the tryplayg IDE to develop the example and It works well. I have to improve it a lot however.

This program calculates speed, time and space. Each one depends on the other two. Each cell has two values: his current entered value and the expression which  calculates it from other cell values/expressions.  circularity is permitted.

The Cell recalculation code uses the famous loeb expression by Dan Piponi in the 2006. Until now by my knowledge there have'nt been any materialization of this formula on a real working spreadsheet. this one is close to it. Since loeb enters in a infinite loop when circular expressions are used, the program counts the loops and reduces complexity by progressively substituting formulas by cell values until the expression has no loops

This program is configured for immediate recalculation on cell change, but that can be adapted to allow the modification of more than one cell before recalculation by triggering it by means of a button.

IDE for Haste projects

I finished an Elm-like IDE for Haste projects. Haste is a compiler from Haskell to Javascript. The software is at: 

https://github.com/agocorona/tryhplay

Running in a heroku instance with a simple example:

http://tryplayg.herokuapp.com/try/console.hs/edit

Besides to edit-compile and run, it can also import , compile and run haste projects from git repositories (Although this, like the rest of the project is experimental).

I use it for my hplayground framework but it can run any haste project.

Using playground is easy to translate console programs to the browser and have reactive effects

A simple example:

http://tryplayg.herokuapp.com/try/fact.hs/edit

the hello-haste example:

http://tryplayg.herokuapp.com/try/hello-haste.hs/edit

Or something more complicated: the todo application, from todoMVC.com written in Haste and hplayground:

http://tryplayg.herokuapp.com/try/todo.hs/edit

rename the programs if you modify them. Follow the instructions to download the HTML generated, that include the Javascript generated. At this time there are no permission controls so it is more or less like a wiki, but heroku from time to time will reset the application.

It is a free instance on heroku so expect delays and request timeouts when many people access to the application. I do not know what will happen.  Feedback welcome

My heroku instance is limited but It is easy to create your own instance in heroku. Follow the install instructions. At:

https://github.com/agocorona/tryhplay/blob/master/README.md

A monad for reactive programming at SOH

Functional reactive programming has no notion of event scope. A functional, declarative, reactive computation is affected as a whole by a signal, and must re-start from the beginning in some way, since it is declarative. A monad can contain the scope of the signal, so part of the computation already done, upstream, do not change when a signal is injected at some level of the computation by an active component.

A monad can decompose the computation in a chain of event handlers virtually set up by the monadic computation when it is called by the top signal, that is, when it is run for the first time. This has many applications, not only in web programmin. I present a mook-up of a comercial application:

A monad for reactive programming  at SOH

Running MFlow applications on Heroku

I updated this entry

http://haskell-web.blogspot.com.es/2013/05/running-mflow-applications-on-heroku.html

Since the method no longer work since it produce timeouts with the modern version of some external libraries. Now the procedure uses anvil and works.

New TODO application for the hplayground client side framework. Feedback welcome

todoMVC.com created a reference application for testing and comparing client side frameworks. 

Well. I did the one for haplaygroud:

Running:
http://mflowdemo.herokuapp.com/todo.html

The code:
https://github.com/agocorona/hplay-todo

You can compare this code with the one of other frameworks. Feedback welcome.

The hplayground git site:
https://github.com/agocorona/hplayground

Some little bugs remain.

hplayground is a haskell framework that compiles to JavaScript (or to HTML directly) using a Haskell to JavaScript compiler : haste.

hplayground code has full reinversion of control. The code look like a console application with no event handlers. It is oriented towards rewrites of the HTML.DOM rather than to achieve dynamic behaviours by means of changing class attributes and hiding elements. therefore the dynamic effects, like edition of entries etc are done in such a way. 

hplayground: write haskell code for the browser console-like and have reactive, window and spreadsheet effects for free

Well this is the time to report something and get some feedback.

I have been trying to port the formlets concept to the client side with a lot of success. I think. The applicative and monadic code of  the MFlow widgets works almost unchanged when compiled to Javacript with the haste compiler.

I called it hplayground since it is more marketable than  Haskell-js-reactive-widgets . And it seems to me something that convert the browser into a playground to essay different things. The DOM tree structure, the HTML formatting, the events,  are not an impediment for making simple things simply. It helps  making complicated things easy since all of them work in harmony.

The examples are alive here:
http://mflowdemo.herokuapp.com/noscript/wiki/browserwidgets

What i achieved?  the possibility to create applications in the browser as fast as easy as console applications and have console, reactive, window-oriented and spreadsheet-like behaviours for free. The mix is a weird but powerful programming something. A kind of having your cake and eat it too.

The problem with the current haskell/elm reactive-declarative developments in the client side is as follows: They all create static layouts with holes that will be modified declaratively expressing reactive dependencies.  The result is that  page content can not be modified, except the holes.

I want everything, including the layout, to be modifiable by the  events.  and this means monadic code. And this means that the layout and the events must run across ifs, elses, case and branches of the code.

The hplayground idea is to use applicative code for static layouts but also monadic code for dynamic updates The events propagate downstream within the monadic code. Whenever that a widget raises an exception, the rest of the monadic computation is triggered, generating new rendering. The events, the computation, the HTML.DOM modifications of the layout follows the same natural and intuitive path within the monadic computation.

This is an static layout with to input boxes with a dynamic part at the end that show the results when the two input boxes validates:

sumtwonumbers = p  "sum two numbers and append the result" ++>

  (p <<< do

     r <- (+) <$> inputInt Nothing `raiseEvent` OnKeyUp <++ br

              <*> inputInt Nothing `raiseEvent` OnKeyUp <++ br

     p <<< fromStr "result: " ++> b (show r) ++> return())

This is a combination of applicative (static) and monadic (dynamic) layout with reactive event handling. When one of the two fields receive a character, the result is updated. If some of the input boxes do not validate, the result line is deleted. It appears when the two boxes validate again.

inputInt :: Maybe Int -> Widget Int

How that happens?  raiseEvent attach an event handler to the input box.  This event handler i re-executes the the current widget and the  rest of the monadic computation down. This rest of the computation rewrite the HTML that generated previously, in this case, the result. So result is erased and rewritten when one of the two input boxes are modified.

raiseEvent :: :: Widget a -> HasteEventType ->Widget a

the layout: 'br' 'p' and the input box etc are  elements of the haste-perch library, described in the previous post.  They are added to the active input elements by means of operators for enclosing (<<<)  prepending (++>)  and postpending (<++).  

<$> and <*> are ordinary applicative combinators and (+) is the sum.

So events, layout and computation follow the same path. You can see a more complex example:

recursivesum :: Widget ()

recursivesum = p  "sum recursively n numbers. When enters 0, present the result" ++> sumr 0

  where

  sumr r=do

    r' <- inputInt Nothing `raiseEvent` OnKeyUp

    if r'== 0

      then  br ++> fromStr "result: " ++>  b (show r) ++> empty

      else do

        b (show $ r+r') ++> br ++> return ()

        sumr (r+r')

Here there is a input box. Initially it is empty so it does not validate and the computation stop there. If the user  enter 0, it present the result. If not it call itself recursively, so it creates another input box and so on. Until 0 is entered and the current sum is presented again below the last input box. If you change an intermediate value in a input box above you can see that the following input boxes are deleted, since the event handler deletes the layout of the continuation and rewrite it. 

There is a version in the examples that remember the old entries using a session context.

This example has a fixed number of input boxes:

sumfold n =  p  ("This widget sum "++ show n ++" numbers and append the result using a fold") ++>


       (p <<< do

         r <- foldl (<>)  (return 0) . take n $ repeat $ inputInt Nothing `raiseEvent` OnKeyUp <++  br

         br ++> fromStr "result: " ++> b (show r) ++> return ())

Since Widget a is a instance of monoid as long as a is a Monoid,  any number of them can be folded.

Graphics are possible also, no news here, since the canvas internal layout is managed by his own monad in Haste. And that is right. However if you look at the "function draw" example and the "gallery" example you can see that the canvas is erased and recreated when the input boxes or a timeout event arrives. The reactive effect of the function draw example is noteworthy.

One more example: The pascal triangle:

-- pascal triangle http://www.haskell.org/haskellwiki/Blow_your_mind



pascal = iterate (\row -> zipWith (+) ([0] ++ row) (row ++ [0])) [1] :: [[Int]]



showpascal n= p << ("Show " ++ show n ++ " rows of the Pascal triangle ")

   ++> mconcat[p ! atr "style" "text-align:center" $ row | row <- take n pascal]

   ++> empty -- the applicative empty === noWidget

Things are not yet finished. I have to create an MFlow application for people to play with the idea. I have to upload the last version of the examples to the page 

http://mflowdemo.herokuapp.com/noscript/wiki/browserwidgets

Where these examples can be seen in action

I have to manage mouse events. It probably will use the same semantics than the wtimeout call, used in the gallery example.

Finally, for the updates of non local elements of the layout that not follow the default downstream flow of a monadic computation (think for example on something like a spreadsheet) Some of them can be done using Haste.DOM primitives , but I have to create high level abstractions like the cell concept. But I have not finished it yet.

By the way, Haste works like a charm. It produces short efficient code. All the examples fit in 100k of javascript code.

At this moment only text boxes and buttons work.  I have to add the dropdowns option buttons and wlinks.  so that full window like applications can be created. I just follow the path of higher resistance and leave the easy things for later.

An finally, some day I will take time to make my presentations, my examples and my texts more readable and more pretty and at least not as dyslexic as they are, but God did not called me to go this path. Too busy programming. Blogger conspirates against me, but I have no clue about what happens with the layout of this page.

To summarize, with little more effort that what you would employ in the creation of a console application and with the same structure, you can create a live dynamic application running in any browser.

Taming the HTML DOM with monads and monoids

Haste is a compiler that generates Javascript code from Haskell.

https://github.com/valderman/haste-compiler

The Haste.DOM module define a thin layer over the JavaScript DOM. That makes the creation and manipulation of DOM elements as painful as in JavaScript. The reason is because to add an element it is necessary two steps: to create the element and get the reference to that elemen, and to append the element as child of the parent.  This linking of references by hand is what makes the creation of dynamic HTML hard, tedious and inelegant.

That is why all the Haskell-Javascript compilers have static HTML demos most of the time, and they concentrate in the creation of graphics, that CAN be programmed in a more pleasant way.

This package makes the creation of DOM elements easy with a syntax similar to other haskell HTML generators, using monoids and monads, such is the case of the package blaze-html.

This is an example. withElem is a Haste.DOM call that give the DOM object whose id is "idelem", that has been created "by hand" in Main.hs. The builder that I created (see the link below) takes this element and add content by defining a hierarchy within the `JSBuilder` monad:

  main= do
   withElem "idelem" . build $ do
    div $ do
       div  $ do
           p "hello"
           nelem "p" `attr` ("style","color:red")  `child`  "world" 
    return ()

   div cont=  nelem "div" `child`  cont

   p cont = nelem "p"  `child`  cont

`child` and `nelem` are defined in the builder too.

No element references have to be managed by the programmer unlike in the case of the plain DOM interface. Try to do it using plain DOM calls.

The output in the browser is:

NOTE: blogger is sooo ugly . Execute it and look at the HTML code for yourself.

The HTML rendering is:

hello

world

How it works? The basic element is a  `builder ` data type that has a "hole" parameter and a IO action which creates the element. The hole contains the parent (Elem) of the element being created.

newtype JSBuilderM a= JSBuilder{build :: Elem -> IO Elem} deriving Typeable



type JSBuilder = JSBuilderM ()

The phanton type 'a' is in order make a valid monad instance of JSBuilderM with the appropriate kind. Nothing more.

Upon created, the elem is added to the parent and return itself as parent of the next elements. That is the creation of an element:

nelem s= JSBuilder $ \e ->do

    e' <-  newElem s

    addChild e' e

    return e'

To append two elements,  it executes the build-link procedure defined for each element to the parent, and return the parent node:

instance Monoid (JSBuilderM a) where

    mappend mx my= JSBuilder $ \e -> do

         build mx e

         build my e

         return e

    mempty  = JSBuilder return

The expression:

build mx e

Executes the IO computation for the creation of the element/elements included (it may be a sub-tree). 

To add a child, the parent's computation is executed, the chid is converted into a builder (using a ToElem instance) and the builder is executed taking the parent as parameter. Finally the parent is returned

child :: ToElem a => JSBuilder -> a -> JSBuilder

child me ch= JSBuilder $ \e' -> do

        e <- build me e'

        let t = toElem ch

        .build t e

        return e

Similarly, to add an attribute to an elem:

attr tag (n, v)=JSBuilder $ \e -> do

        tag' $lt;-  build tag e

        setAttr tag' n v

        return tag'

The Monad instance is there in order to use the do notation.  This add a new level of syntax, in the style of the package blaze-html. This monad invokes the same appending mechanism.

This makes the creation of dynamic Web apps in the browser with texts and formatting far more easy, as a seamless declarative sequence with the shape of the DOM three being created, rather than as a imperative sequence full of seams.

The equivalent monoid expression can also be used, by concatenating elements with the operator <> or mappend

I guess this technique can be generalized for the creation of any tree data structure and any kind of tree management primitives.

The code and how it works, the demo etc is here:

https://github.com/agocorona/haskell-js-html-builder

UPDATE:
this software is now called "perch" and is published in the hackage repository. It support now the same syntax than blaze-html including attribute (!) operators etc.

https://hackage.haskell.org/package/haste-perch

Separation of concerns by the problem domain, not by tecnology - Composable caching

The "separation of concern" -as is understood by MVC Web frameworks- does not  separate concerns really. A separation of concern forced by  technological problems rather than being separated by components of the problem domain is like saying that I live better as an slave because I have no need to be concerned by how good or bad the master behave. Caching is an example of this contradiction.

The MVC model forces his own separation of concern and it is inherently non composable. It does not allow to create self contained elements -with M V and C components inside- that can be composed to create applications. That means that it can not separate the concerns in terms of application functionalities: login, payment, content management, lazy loading,  auto-completion widgets etc. As well as other functionalities specific of the individual application. The separation is dictated from below. That is because the technologies involved: event-driven graphical presentation, transactional data management and business logic are not yet fully integrated. See: Towards a deeper integration: A Web language

Concerning caching, A HTTP guru, probably in other department does not know for how long your particular data is valid . Neither you know if the HTTP guru will cache your fresh data in order to avoid loading the server, so you will add a random string to your data to avoid caching. In any case, there is a opportunity lost for optimizing the load of the server without impairing the interaction.

Now the new composable caching policies of MFlow permits the use of aggressive caching policies even for highly dynamic pages, since expressing cache directives is in the hands of the programmer of each particular widget. 

What if you, the programmer of a widget can say to the page: "this widget present data that can be cached for 200 seconds, no matter if it is part of a page or if its data is sent trough Ajax". Or: "the user has logged-in so this page must be private, no matter the policies of the rest of the widgets".

What if the page can get all the cache policies of all the widgets and insert the most restrictive ones in the HTTP header?

Then we would have a true separation of concern without impairing synergies.

If the widget is refreshed using ajax, only the individual cache policy of the widget is taken into account. For example: I´m logged here as editor, so the login widget detect this condition and mark the page as private. But If I click an autorefreshed widget which is not marked as private and have a maxAge directive, the menu options on the left, for example, then the menus can be cached within network proxies and CDNs, so other users can make use of these cached resources without compromising my privacy.

Going this way, more synergies appear in unsuspected ways;  What is the killer application of the JavasCript frameworks?  To present data sets without repeated accesses to the server using the new HTML5 cache.  Now this can be done by caching AJAX responses in the good old HTTP cache, and make it work in any browser without explicit JavaScript programming.

Because blogger is almost impossible to tame for me. I leave a link to the full article about composable caching in the MFlow demo site:

http://mflowdemo.herokuapp.com/noscript/wiki/cachingdfield

See also: Navigating an (infinite) dataset