concur-documentation

The way the generators appear to work reminds me a lot of Concur: https://github.com/ajnsit/concur-documentation But controlling or understanding the control flow in Crank generator components, ie. when does ‘yield‘ return, looks like a bit of a nightmare!

I simply love it how every single Haskell framework I've seen that has "ease of development" and "it's easy" and similar immediately devolves from this (from Concur's docs [1]): hello = do button [onClick] [text "Say Hello"] text "Hello Sailor!" into this: inputWidget = input [(Changed <<< unsafeTargetValue) <$> onChange, Focused <$ onFocus] or this: inputWidget st = input [st {focusCount = st.focusCount+1} <$ onFocus , ((\s -> st {currentText = s}) <<< unsafeTargetValue) <$> onChange] for even the slightest modifications (which are not even complex in this case) These instances, allow a natural handling of return values using <$>, <*>, <$, monadic do-notation, etc Right... [1] https://github.com/ajnsit/concur-documentation/blob/master/R...

That was the only programming environment (CA-Clipper) I knew at the time. VB6 was a thing, but I had some GUI-antipathy, coming from the older, "purer?" world of DOS. Also POS terminals needed first-class keyboard accessibility. SQL wasn't welcome either - you had to give up the fine grained control of row-level cursors in the flat-file xBase database and use a rather unwieldy looking language. I would still love to go back to the ergonomics of building user interfaces in DOS. No mouse, no events, no callbacks - just straight imperative programming where everything, including user input, blocks. Nothing async - even network communication was thru Novell Netware file writes, using shared locks. And a single screen to design: 25 rows and 80 columns, and just 16 colors. After doing GUI work for many years after DOS, thru VB6, jQuery DOM man

Recently I started playing with https://github.com/ajnsit/concur-documentation/blob/master/R... which has been the most refreshing UI paradigm i've used in a while. and it reminds me a lot of this ImGUI approach, but behind the scenes it uses coroutines instead. The idea is that a button is a UI element that _blocks_ until an event is fired. You can then compose elements in time like: button "hey" >> label "clicked" which is a program that displays a button, you click it, the button goes away and the text "clicked appears" Or you can compose programs in space: (button "hey" <> label "not clicked") this is a program that displays both a button, and a label at the same time. Now, by combining both space and time, we can create a program that changes the label when clicking as follows: program = (button "toggle" <> label "o

I wrote a UI framework called Concur which is very similar to immediate mode UIs and hence very easy to use, but also scales fantastically well to complex UIs. The original code was written in Haskell (https://github.com/ajnsit/concur), and then ported to Purescript (https://github.com/ajnsit/purescript-concur), and even Javascript (https://github.com/ajnsit/concur-js). There's an introduction/tutorial here - https://github.com/ajnsit/concur-documentation/blob/master/R...

If you want something that's (really) easy to get started with, and yet won't artificially constrain you from using your functional programming tricks as you evolve, I recommend trying out Concur [Haskell version](https://github.com/ajnsit/concur) or [Purescript version](https://github.com/ajnsit/purescript-concur). I wrote an initial introduction which also compares it with elm - https://github.com/ajnsit/concur-documentation/blob/master/R....