Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alberto G. Corona]

However, besides state synchronization is under development, state
persistence in MFlow is optional,  by using  the workflow monad instead of
the IO monad.  See for example this:

http://mflowdemo.herokuapp.com/shop



2013/7/10 Alberto G. Corona 

> My plan is to synchronize MFlow servers using cloud Haskell since the
> state serialization is small. I´m working on it.  However continuation
> based frameworks can not synchronize state.  There is "swarm" in scala that
> generate portable continuations but this is not used in the context of web
> application since the state in a continuation is big and can not be
> synchronized fast enough. In other languages these states are not even
> portable between machines.
>
>
> 2013/7/10 Alexander Kjeldaas 
>
>> Here are some common-lisp web frameworks using continuations:
>>
>> http://common-lisp.net/project/cl-weblocks/
>> http://common-lisp.net/project/ucw/features.html
>>
>> What always worried me with these frameworks is how they could be made
>> robust in case of failures.  Storing all state in a database backend often
>> makes it possible to isolate failures.  However, it seems to me that it is
>> be possible to solve this in Haskell where state can be serialized and
>> synchronized between multiple machines using Cloud Haskell, something that
>> is error-prone or impossible in other languages.  But that step has never
>> been taken.
>>
>> Alexander
>>
>>
>> On Wed, Jul 10, 2013 at 4:48 PM, Alberto G. Corona 
>> wrote:
>>
>>> Thanks Adrian. The racket people where pioneers in this idea I think.
>>>
>>> There is another web framework in Ocaml, Osigen that it is also
>>> continuation based. MFlow is not continuation-based but it also define the
>>> navigation as a sequence. But only Seaside (and now MFlow) supports many
>>> flows in the same page. See for example this:
>>>
>>> [PDF] *Seaside* – A *Multiple* Control *Flow* Web Application 
>>> Framework
>>>
>>> There is also other: Apache Coccoon that run in a special kind of
>>> JavaScript. The continuation-based frameworks have the reputation of
>>> storing a lot of application state and to be non  scalable. MFlow
>>> uses backtracking and It does not have these problems.
>>>
>>>
>>> 2013/7/10 Adrian May 
>>>
 Oh how nice!

 I have been looking at MFlow a lot lately and I think it's got
 something quite special that Yesod, Happstack, etc don't seem to have, at
 least, not as far as I know. I mean, look at this:

 sumWidget= pageFlow "sum" $ do

   n1 <- p << "Enter first number"  ++> getInt Nothing <** submitButton 
 "enter" <++ br






   n2 <- p << "Enter second number" ++> getInt Nothing <** submitButton 
 "enter" <++ br






   n3 <- p << "Enter third number"  ++> getInt Nothing <** submitButton 
 "enter" <++ br






   p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () << b 
 << " menu"






   <++ p << "you can change the numbers in the boxes to see how the 
 result changes"

 Is that pretty or what? That's the code for this:

 http://mflowdemo.herokuapp.com/noscript/fviewmonad

 To me that's a real technological step over and above the usual
 servlets paradigm and I'd love to see more people getting involved. It
 seems like Yesod and Happstack have a lot more manpower behind them, but
 unless I've missed something, MFlow is going somewhere new and should be
 helped along.

 Adrian.

 PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
 McCarthy) have something to say about performance but I didn't quite
 understand it.



 On 10 July 2013 06:41, Alberto G. Corona  wrote:

> The third version of MFlow is out.
>
> http://hackage.haskell.org/package/MFlow
>
> MFlow is an all-heterodox web application framework, but very
> haskellish.
>
> Now MFlow support restful URLs.  It is the first stateful web
> framework to my knowledge that supports it. The type safe routes are
> implicitly expressed as normal monadic code within a navigation monad. The
> application look as a normal imperative console application, but the
> navigation monad goes back and forth to match the path of the URL. The 
> user
> has control of the state, that can roll-back or not when the navigation
> goes back depending on the application needs. The state is in the form of
> normal Haskell variables In a monadic computation, with the weird addition
> of backtracking.
>
> The menu of the application below is implemente

Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alberto G. Corona]

I factored out the submit buttons.

Now the three text boxes appear in succession above a unique button below.

http://mflowdemo.herokuapp.com/noscript/fviewmonad

This is the new code:

sumWidget=  pageFlow "sum" $ do

  n ←  (do
   n1 ←  p << "Enter first number"   ++> getInt Nothing <++ br
   n2 ←  p << "Enter second number" ++> getInt Nothing <++ br
   n3 ←  p << "Enter third number"  ++> getInt Nothing <++ br
   return (n1+ n2 + n3))

  <**  pageFlow "button" (submitButton "submit")

   p <<  ("The result is: "++show n)  ++>  wlink () << b << " menu"
   <++ p << "you can change the numbers in the boxes to see how the
result changes"




2013/7/10 Adrian May 

> Oh how nice!
>
> I have been looking at MFlow a lot lately and I think it's got something
> quite special that Yesod, Happstack, etc don't seem to have, at least, not
> as far as I know. I mean, look at this:
>
> sumWidget= pageFlow "sum" $ do
>
>   n1 <- p << "Enter first number"  ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   n2 <- p << "Enter second number" ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   n3 <- p << "Enter third number"  ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () << b << " 
> menu"
>
>   <++ p << "you can change the numbers in the boxes to see how the result 
> changes"
>
> Is that pretty or what? That's the code for this:
>
> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>
> To me that's a real technological step over and above the usual servlets
> paradigm and I'd love to see more people getting involved. It seems like
> Yesod and Happstack have a lot more manpower behind them, but unless I've
> missed something, MFlow is going somewhere new and should be helped along.
>
> Adrian.
>
> PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
> McCarthy) have something to say about performance but I didn't quite
> understand it.
>
>
>
> On 10 July 2013 06:41, Alberto G. Corona  wrote:
>
>> The third version of MFlow is out.
>>
>> http://hackage.haskell.org/package/MFlow
>>
>> MFlow is an all-heterodox web application framework, but very haskellish.
>>
>> Now MFlow support restful URLs.  It is the first stateful web framework
>> to my knowledge that supports it. The type safe routes are implicitly
>> expressed as normal monadic code within a navigation monad. The application
>> look as a normal imperative console application, but the navigation monad
>> goes back and forth to match the path of the URL. The user has control of
>> the state, that can roll-back or not when the navigation goes back
>> depending on the application needs. The state is in the form of normal
>> Haskell variables In a monadic computation, with the weird addition of
>> backtracking.
>>
>> The menu of the application below is implemented as an imperative-like
>> syntax, but the application navigate forward and backward to synchronize
>> with the requests of the web browser:
>> http://mflowdemo.herokuapp.com/
>>
>> This version support  in-page flows.
>>  What is that? look at this example:
>>
>> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>>
>> These flows are implemented as formlets with a monad instance, and
>> callbacks which change the look. I call them "widgets":
>>
>>
>> http://haskell-web.blogspot.com.es/2013/06/the-promising-land-of-monadic-formlets.html
>>
>>
>> Each page may have many  of these active widgets, each one running their
>> own flow. These widgets refresh themselves trough Ajax if they are enclosed
>> in the primitive "autoRefresh". If there is no Ajax or JavaScript
>> available, they gracefully degrade by refreshing the entire page:
>>
>> http://mflowdemo.herokuapp.com/noscript/combination
>>
>>
>> http://haskell-web.blogspot.com.es/2013/06/and-finally-widget-auto-refreshing.html
>>
>> The page flows and the multiflow idea was inspired in 
>> Seaside,
>> a great Smalltalk web framework and adapted to the pure recursive nature of
>> Haskell and the formlets.
>>
>> It also support some JQuery widgets integrated: modal and not modal
>> dialogs, datePicker and other active widgets that handle other widgets.
>>
>> It also support the older features: persistent state, WAI, blaze-html and
>> others integration, server process timeouts, Ajax, requirements,
>>  content management, caching of widget rendering and all the other
>> previous stuff.
>>
>> I wish to thank some people for their feedback. Specially Adrian May for
>> his feedback and interest
>>
>>
>> --
>> Alberto.
>>
>> ___
>> Haskell-Cafe mailing list
>> Haskell-Cafe@haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
> ___
> Haskell-Cafe mailing list
> Haskell-Cafe@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>


-- 

Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alberto G. Corona]

My plan is to synchronize MFlow servers using cloud Haskell since the state
serialization is small. I´m working on it.  However continuation based
frameworks can not synchronize state.  There is "swarm" in scala that
generate portable continuations but this is not used in the context of web
application since the state in a continuation is big and can not be
synchronized fast enough. In other languages these states are not even
portable between machines.


2013/7/10 Alexander Kjeldaas 

> Here are some common-lisp web frameworks using continuations:
>
> http://common-lisp.net/project/cl-weblocks/
> http://common-lisp.net/project/ucw/features.html
>
> What always worried me with these frameworks is how they could be made
> robust in case of failures.  Storing all state in a database backend often
> makes it possible to isolate failures.  However, it seems to me that it is
> be possible to solve this in Haskell where state can be serialized and
> synchronized between multiple machines using Cloud Haskell, something that
> is error-prone or impossible in other languages.  But that step has never
> been taken.
>
> Alexander
>
>
> On Wed, Jul 10, 2013 at 4:48 PM, Alberto G. Corona wrote:
>
>> Thanks Adrian. The racket people where pioneers in this idea I think.
>>
>> There is another web framework in Ocaml, Osigen that it is also
>> continuation based. MFlow is not continuation-based but it also define the
>> navigation as a sequence. But only Seaside (and now MFlow) supports many
>> flows in the same page. See for example this:
>>
>> [PDF] *Seaside* – A *Multiple* Control *Flow* Web Application 
>> Framework
>>
>> There is also other: Apache Coccoon that run in a special kind of
>> JavaScript. The continuation-based frameworks have the reputation of
>> storing a lot of application state and to be non  scalable. MFlow
>> uses backtracking and It does not have these problems.
>>
>>
>> 2013/7/10 Adrian May 
>>
>>> Oh how nice!
>>>
>>> I have been looking at MFlow a lot lately and I think it's got something
>>> quite special that Yesod, Happstack, etc don't seem to have, at least, not
>>> as far as I know. I mean, look at this:
>>>
>>> sumWidget= pageFlow "sum" $ do
>>>
>>>   n1 <- p << "Enter first number"  ++> getInt Nothing <** submitButton 
>>> "enter" <++ br
>>>
>>>
>>>
>>>
>>>
>>>   n2 <- p << "Enter second number" ++> getInt Nothing <** submitButton 
>>> "enter" <++ br
>>>
>>>
>>>
>>>
>>>
>>>   n3 <- p << "Enter third number"  ++> getInt Nothing <** submitButton 
>>> "enter" <++ br
>>>
>>>
>>>
>>>
>>>
>>>   p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () << b << 
>>> " menu"
>>>
>>>
>>>
>>>
>>>
>>>   <++ p << "you can change the numbers in the boxes to see how the 
>>> result changes"
>>>
>>> Is that pretty or what? That's the code for this:
>>>
>>> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>>>
>>> To me that's a real technological step over and above the usual servlets
>>> paradigm and I'd love to see more people getting involved. It seems like
>>> Yesod and Happstack have a lot more manpower behind them, but unless I've
>>> missed something, MFlow is going somewhere new and should be helped along.
>>>
>>> Adrian.
>>>
>>> PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
>>> McCarthy) have something to say about performance but I didn't quite
>>> understand it.
>>>
>>>
>>>
>>> On 10 July 2013 06:41, Alberto G. Corona  wrote:
>>>
 The third version of MFlow is out.

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

 MFlow is an all-heterodox web application framework, but very
 haskellish.

 Now MFlow support restful URLs.  It is the first stateful web framework
 to my knowledge that supports it. The type safe routes are implicitly
 expressed as normal monadic code within a navigation monad. The application
 look as a normal imperative console application, but the navigation monad
 goes back and forth to match the path of the URL. The user has control of
 the state, that can roll-back or not when the navigation goes back
 depending on the application needs. The state is in the form of normal
 Haskell variables In a monadic computation, with the weird addition of
 backtracking.

 The menu of the application below is implemented as an imperative-like
 syntax, but the application navigate forward and backward to synchronize
 with the requests of the web browser:
 http://mflowdemo.herokuapp.com/

 This version support  in-page flows.
  What is that? look at this example:

 http://mflowdemo.herokuapp.com/noscript/fviewmonad

 These flows are implemented as formlets with a monad instance, and
 ca

Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alexander Kjeldaas]

Here are some common-lisp web frameworks using continuations:

http://common-lisp.net/project/cl-weblocks/
http://common-lisp.net/project/ucw/features.html

What always worried me with these frameworks is how they could be made
robust in case of failures.  Storing all state in a database backend often
makes it possible to isolate failures.  However, it seems to me that it is
be possible to solve this in Haskell where state can be serialized and
synchronized between multiple machines using Cloud Haskell, something that
is error-prone or impossible in other languages.  But that step has never
been taken.

Alexander


On Wed, Jul 10, 2013 at 4:48 PM, Alberto G. Corona wrote:

> Thanks Adrian. The racket people where pioneers in this idea I think.
>
> There is another web framework in Ocaml, Osigen that it is also
> continuation based. MFlow is not continuation-based but it also define the
> navigation as a sequence. But only Seaside (and now MFlow) supports many
> flows in the same page. See for example this:
>
> [PDF] *Seaside* – A *Multiple* Control *Flow* Web Application 
> Framework
>
> There is also other: Apache Coccoon that run in a special kind of
> JavaScript. The continuation-based frameworks have the reputation of
> storing a lot of application state and to be non  scalable. MFlow
> uses backtracking and It does not have these problems.
>
>
> 2013/7/10 Adrian May 
>
>> Oh how nice!
>>
>> I have been looking at MFlow a lot lately and I think it's got something
>> quite special that Yesod, Happstack, etc don't seem to have, at least, not
>> as far as I know. I mean, look at this:
>>
>> sumWidget= pageFlow "sum" $ do
>>
>>   n1 <- p << "Enter first number"  ++> getInt Nothing <** submitButton 
>> "enter" <++ br
>>
>>
>>
>>   n2 <- p << "Enter second number" ++> getInt Nothing <** submitButton 
>> "enter" <++ br
>>
>>
>>
>>   n3 <- p << "Enter third number"  ++> getInt Nothing <** submitButton 
>> "enter" <++ br
>>
>>
>>
>>   p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () << b << 
>> " menu"
>>
>>
>>
>>   <++ p << "you can change the numbers in the boxes to see how the 
>> result changes"
>>
>> Is that pretty or what? That's the code for this:
>>
>> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>>
>> To me that's a real technological step over and above the usual servlets
>> paradigm and I'd love to see more people getting involved. It seems like
>> Yesod and Happstack have a lot more manpower behind them, but unless I've
>> missed something, MFlow is going somewhere new and should be helped along.
>>
>> Adrian.
>>
>> PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
>> McCarthy) have something to say about performance but I didn't quite
>> understand it.
>>
>>
>>
>> On 10 July 2013 06:41, Alberto G. Corona  wrote:
>>
>>> The third version of MFlow is out.
>>>
>>> http://hackage.haskell.org/package/MFlow
>>>
>>> MFlow is an all-heterodox web application framework, but very
>>> haskellish.
>>>
>>> Now MFlow support restful URLs.  It is the first stateful web framework
>>> to my knowledge that supports it. The type safe routes are implicitly
>>> expressed as normal monadic code within a navigation monad. The application
>>> look as a normal imperative console application, but the navigation monad
>>> goes back and forth to match the path of the URL. The user has control of
>>> the state, that can roll-back or not when the navigation goes back
>>> depending on the application needs. The state is in the form of normal
>>> Haskell variables In a monadic computation, with the weird addition of
>>> backtracking.
>>>
>>> The menu of the application below is implemented as an imperative-like
>>> syntax, but the application navigate forward and backward to synchronize
>>> with the requests of the web browser:
>>> http://mflowdemo.herokuapp.com/
>>>
>>> This version support  in-page flows.
>>>  What is that? look at this example:
>>>
>>> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>>>
>>> These flows are implemented as formlets with a monad instance, and
>>> callbacks which change the look. I call them "widgets":
>>>
>>>
>>> http://haskell-web.blogspot.com.es/2013/06/the-promising-land-of-monadic-formlets.html
>>>
>>>
>>> Each page may have many  of these active widgets, each one running their
>>> own flow. These widgets refresh themselves trough Ajax if they are enclosed
>>> in the primitive "autoRefresh". If there is no Ajax or JavaScript
>>> available, they gracefully degrade by refreshing the entire page:
>>>
>>> http://mflowdemo.herokuapp.com/noscript/combination
>>>
>>>
>>> http://haskell-web.blogspot.com.es/2013/06/and-finally-widget-auto-refreshing.html
>>>
>>> The page flows and the multif

Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alberto G. Corona]

Thanks Adrian. The racket people where pioneers in this idea I think.

There is another web framework in Ocaml, Osigen that it is also
continuation based. MFlow is not continuation-based but it also define the
navigation as a sequence. But only Seaside (and now MFlow) supports many
flows in the same page. See for example this:

[PDF] *Seaside* – A *Multiple* Control *Flow* Web Application
Framework

There is also other: Apache Coccoon that run in a special kind of
JavaScript. The continuation-based frameworks have the reputation of
storing a lot of application state and to be non  scalable. MFlow
uses backtracking and It does not have these problems.


2013/7/10 Adrian May 

> Oh how nice!
>
> I have been looking at MFlow a lot lately and I think it's got something
> quite special that Yesod, Happstack, etc don't seem to have, at least, not
> as far as I know. I mean, look at this:
>
> sumWidget= pageFlow "sum" $ do
>
>   n1 <- p << "Enter first number"  ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   n2 <- p << "Enter second number" ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   n3 <- p << "Enter third number"  ++> getInt Nothing <** submitButton 
> "enter" <++ br
>
>   p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () << b << " 
> menu"
>
>   <++ p << "you can change the numbers in the boxes to see how the result 
> changes"
>
> Is that pretty or what? That's the code for this:
>
> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>
> To me that's a real technological step over and above the usual servlets
> paradigm and I'd love to see more people getting involved. It seems like
> Yesod and Happstack have a lot more manpower behind them, but unless I've
> missed something, MFlow is going somewhere new and should be helped along.
>
> Adrian.
>
> PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
> McCarthy) have something to say about performance but I didn't quite
> understand it.
>
>
>
> On 10 July 2013 06:41, Alberto G. Corona  wrote:
>
>> The third version of MFlow is out.
>>
>> http://hackage.haskell.org/package/MFlow
>>
>> MFlow is an all-heterodox web application framework, but very haskellish.
>>
>> Now MFlow support restful URLs.  It is the first stateful web framework
>> to my knowledge that supports it. The type safe routes are implicitly
>> expressed as normal monadic code within a navigation monad. The application
>> look as a normal imperative console application, but the navigation monad
>> goes back and forth to match the path of the URL. The user has control of
>> the state, that can roll-back or not when the navigation goes back
>> depending on the application needs. The state is in the form of normal
>> Haskell variables In a monadic computation, with the weird addition of
>> backtracking.
>>
>> The menu of the application below is implemented as an imperative-like
>> syntax, but the application navigate forward and backward to synchronize
>> with the requests of the web browser:
>> http://mflowdemo.herokuapp.com/
>>
>> This version support  in-page flows.
>>  What is that? look at this example:
>>
>> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>>
>> These flows are implemented as formlets with a monad instance, and
>> callbacks which change the look. I call them "widgets":
>>
>>
>> http://haskell-web.blogspot.com.es/2013/06/the-promising-land-of-monadic-formlets.html
>>
>>
>> Each page may have many  of these active widgets, each one running their
>> own flow. These widgets refresh themselves trough Ajax if they are enclosed
>> in the primitive "autoRefresh". If there is no Ajax or JavaScript
>> available, they gracefully degrade by refreshing the entire page:
>>
>> http://mflowdemo.herokuapp.com/noscript/combination
>>
>>
>> http://haskell-web.blogspot.com.es/2013/06/and-finally-widget-auto-refreshing.html
>>
>> The page flows and the multiflow idea was inspired in 
>> Seaside,
>> a great Smalltalk web framework and adapted to the pure recursive nature of
>> Haskell and the formlets.
>>
>> It also support some JQuery widgets integrated: modal and not modal
>> dialogs, datePicker and other active widgets that handle other widgets.
>>
>> It also support the older features: persistent state, WAI, blaze-html and
>> others integration, server process timeouts, Ajax, requirements,
>>  content management, caching of widget rendering and all the other
>> previous stuff.
>>
>> I wish to thank some people for their feedback. Specially Adrian May for
>> his feedback and interest
>>
>>
>> --
>> Alberto.
>>
>> ___
>> Haskell-Cafe mailing list
>> Haskell-Cafe@haskell.org
>> http://www.haskell.org/ma

Re: [Haskell-cafe] ANNOUNCE: MFlow 3.0

[Adrian May]

Oh how nice!

I have been looking at MFlow a lot lately and I think it's got something
quite special that Yesod, Happstack, etc don't seem to have, at least, not
as far as I know. I mean, look at this:

sumWidget= pageFlow "sum" $ do
  n1 <- p << "Enter first number"  ++> getInt Nothing <**
submitButton "enter" <++ br
  n2 <- p << "Enter second number" ++> getInt Nothing <**
submitButton "enter" <++ br
  n3 <- p << "Enter third number"  ++> getInt Nothing <**
submitButton "enter" <++ br
  p <<  ("The result is: "++show (n1 + n2 + n3))  ++>  wlink () <<
b << " menu"
  <++ p << "you can change the numbers in the boxes to see how the
result changes"

Is that pretty or what? That's the code for this:

http://mflowdemo.herokuapp.com/noscript/fviewmonad

To me that's a real technological step over and above the usual servlets
paradigm and I'd love to see more people getting involved. It seems like
Yesod and Happstack have a lot more manpower behind them, but unless I've
missed something, MFlow is going somewhere new and should be helped along.

Adrian.

PS. Besides Seaside, Racket is playing with the same ideas. They (Jay
McCarthy) have something to say about performance but I didn't quite
understand it.



On 10 July 2013 06:41, Alberto G. Corona  wrote:

> The third version of MFlow is out.
>
> http://hackage.haskell.org/package/MFlow
>
> MFlow is an all-heterodox web application framework, but very haskellish.
>
> Now MFlow support restful URLs.  It is the first stateful web framework to
> my knowledge that supports it. The type safe routes are implicitly
> expressed as normal monadic code within a navigation monad. The application
> look as a normal imperative console application, but the navigation monad
> goes back and forth to match the path of the URL. The user has control of
> the state, that can roll-back or not when the navigation goes back
> depending on the application needs. The state is in the form of normal
> Haskell variables In a monadic computation, with the weird addition of
> backtracking.
>
> The menu of the application below is implemented as an imperative-like
> syntax, but the application navigate forward and backward to synchronize
> with the requests of the web browser:
> http://mflowdemo.herokuapp.com/
>
> This version support  in-page flows.
>  What is that? look at this example:
>
> http://mflowdemo.herokuapp.com/noscript/fviewmonad
>
> These flows are implemented as formlets with a monad instance, and
> callbacks which change the look. I call them "widgets":
>
>
> http://haskell-web.blogspot.com.es/2013/06/the-promising-land-of-monadic-formlets.html
>
>
> Each page may have many  of these active widgets, each one running their
> own flow. These widgets refresh themselves trough Ajax if they are enclosed
> in the primitive "autoRefresh". If there is no Ajax or JavaScript
> available, they gracefully degrade by refreshing the entire page:
>
> http://mflowdemo.herokuapp.com/noscript/combination
>
>
> http://haskell-web.blogspot.com.es/2013/06/and-finally-widget-auto-refreshing.html
>
> The page flows and the multiflow idea was inspired in 
> Seaside,
> a great Smalltalk web framework and adapted to the pure recursive nature of
> Haskell and the formlets.
>
> It also support some JQuery widgets integrated: modal and not modal
> dialogs, datePicker and other active widgets that handle other widgets.
>
> It also support the older features: persistent state, WAI, blaze-html and
> others integration, server process timeouts, Ajax, requirements,
>  content management, caching of widget rendering and all the other
> previous stuff.
>
> I wish to thank some people for their feedback. Specially Adrian May for
> his feedback and interest
>
>
> --
> Alberto.
>
> ___
> Haskell-Cafe mailing list
> Haskell-Cafe@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] ANNOUNCE: MFlow 3.0

[Alberto G. Corona]

The third version of MFlow is out.

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

MFlow is an all-heterodox web application framework, but very haskellish.

Now MFlow support restful URLs.  It is the first stateful web framework to
my knowledge that supports it. The type safe routes are implicitly
expressed as normal monadic code within a navigation monad. The application
look as a normal imperative console application, but the navigation monad
goes back and forth to match the path of the URL. The user has control of
the state, that can roll-back or not when the navigation goes back
depending on the application needs. The state is in the form of normal
Haskell variables In a monadic computation, with the weird addition of
backtracking.

The menu of the application below is implemented as an imperative-like
syntax, but the application navigate forward and backward to synchronize
with the requests of the web browser:
http://mflowdemo.herokuapp.com/

This version support  in-page flows.
 What is that? look at this example:

http://mflowdemo.herokuapp.com/noscript/fviewmonad

These flows are implemented as formlets with a monad instance, and
callbacks which change the look. I call them "widgets":

http://haskell-web.blogspot.com.es/2013/06/the-promising-land-of-monadic-formlets.html


Each page may have many  of these active widgets, each one running their
own flow. These widgets refresh themselves trough Ajax if they are enclosed
in the primitive "autoRefresh". If there is no Ajax or JavaScript
available, they gracefully degrade by refreshing the entire page:

http://mflowdemo.herokuapp.com/noscript/combination

http://haskell-web.blogspot.com.es/2013/06/and-finally-widget-auto-refreshing.html

The page flows and the multiflow idea was inspired in
Seaside,
a great Smalltalk web framework and adapted to the pure recursive nature of
Haskell and the formlets.

It also support some JQuery widgets integrated: modal and not modal
dialogs, datePicker and other active widgets that handle other widgets.

It also support the older features: persistent state, WAI, blaze-html and
others integration, server process timeouts, Ajax, requirements,
 content management, caching of widget rendering and all the other previous
stuff.

I wish to thank some people for their feedback. Specially Adrian May for
his feedback and interest


-- 
Alberto.
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe