[Haskell-cafe] ANNOUNCE: MFlow-0.1.5

[Alberto G. Corona]

Hi haskellers and specially the web developers.

http://hackage.haskell.org/package/MFlow-0.1.5.3

MFlow is a is a Web framework with some unique, and I mean unique,
characteristics that I find exciting:

- It is a Web application server that start and restart on-demand
stateful web server processes (not request.-response)
  This means that all the page navigation can be coded in a single
procedure. This increases readability of the programmer code. I woul
call it
a anti-node.js.  Buit usual request-response (stateless) server
processes are also allowed

- When the process is invoqued as result of an URL request, the Web
app server not only restart the process but also recover its execution
state. The enclosing Workflow monad provides the thread state
persistence. There are state timeouts and process timeouts defined by
the programmer. Processes with no persistent state (transient) are
possible.

-The user interface is made of widgets. They are  formlets with added
formatting,   attributes, validations, modifiers and callbacks, that
are composable, so the pieces are reusable and return type safe
responses to the calling process. Even the links are part of widgets
and return back type safe inputs at compile time to the calling server
process. Tho glue these components, ordinary applicative combinators
and other extra combinators are used.

- The widgets and the communication don´t make assumptions about the
architecture, so it can be adapted to non-web environments. This
versions has interface for WAI-warp, Hack, Text.XHtml (xhtml) , and
Haskell Server Pages.

-The widget rendering can be converted to ByteStrings automatically
with special combinators. A mix of widgets with different formats can
be combined in the same source file. For example Text.Html and HSP
(Haskell server pages)

-These widgets can be cached, to avoid widget rendering on every interaction.

-To handle the back button, and because the processes are stateful,
they can run backwards until the response match. This is transparent
for the programmer, thanks to the embedded FlowM monad.

-All the code is in pure Haskell. No deployment, special scripts,
formats etc are necessary.

-Besides automatic state persistence, TCache provides transactions and
user data persistence, that can be configured for SQL databases.
Default persistence in files permit very rapid prototyping. Just code
and run it with runghc.

-Has AJAX support

All of this sounds very complicated, but really it is simple!. Most of
these things are transparent. The resulting code is quite readable and
has very little plumbing!

There is a non trivial example that some of these functionalities
embedded here that you can run:

 http://hackage.haskell.org/packages/archive/MFlow/0.1.5.3/doc/html/MFlow-Forms.html

Take a look and tell me your opinion.  I hope that you find it as
exciting as me.

 I´m looking for people  to collaborate in the development of MFlow.

Although still it is experimental, it is being used in at least one
future commercial project. So I have te commitment to continue its
development. There are many examples in the documentation and in the
package.

Alberto