Good examples of CQRS / EventSourcing in functional language

[Jpup]

Hi All,

Just watch another of Greg's Talks - 

Event Sourcing is actually just functional code

https://www.youtube.com/watch?v=kZL41SMXWdM

It piqued my interest, having gone through and still working through building my first CQRS/ES implementation in Go and now I know a lot more about the topic in a non functional language now than I did a few months ago. Along this journey I have seen many mentions of functional language implementations being the most elegant solutions, I would like to look at what a good functional implementation looks like.

Does anyone have any recommendations for reference applications, videos or any other material that is worth looking at?

[David Reaver]

I've been using Event sourcing in a personal project in Haskell for the past few weeks (for context, it's an algorithmic trading application). I think this paradigm fits a function language extremely well. I don't have a reference application for you, but here are a few resources I've collected:

• A blog post on using CQRS/ES in production at a financial startup. They built a really neat type class in Haskell for the models, and also some monadic types for services: https://abailly.github.io/posts/cm-arch-design.html
• A Haskell event sourcing library from the author of the above blog post. I don't use this, but there are a lot of good ideas in it: https://github.com/abailly/hevents
• A very small and very simple Haskell application using an Aggregate class: https://gist.github.com/Fristi/7327904
• A presentation on event sourcing with Haskell and Scala exmaples: http://www.slideshare.net/chris.e.richardson/developing-functional-domain-models-with-event-sourcing-sbtb-sbtb2015

Googling any combination of "Event sourcing", "CQRS", "funtional programming", "Haskell", etc will probably yield some great results too (basically how I found all of this). I'm not an event sourcing or CQRS expert by any means, but I do write Haskell for a living, and so far I've had some great results building and designing my project using CQRS/ES in Haskell.

I think it's unfortunate that a lot of the literature in this space is so heavily intertwined with object oriented programming and .NET, because CQRS/ES is a great fit for a functional language. (This is probably just due to statistics; more people use .NET languages than Haskell!)

I hope others respond with some more resources! I'd love to see what others have done.

- David

--
You received this message because you are subscribed to the Google Groups "DDD/CQRS" group.
To unsubscribe from this group and stop receiving emails from it, send an email to dddcqrs+u...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Greg Young]

Check out Jeremie's (thinkbeforecoding) F# version of simple cqrs

https://github.com/thinkbeforecoding/m-r/tree/FSharp/FsSimpleCQRS

> --
> You received this message because you are subscribed to the Google Groups
> "DDD/CQRS" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to dddcqrs+u...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

--
Studying for the Turing test

[Jpup]

Oh wow, it is very light compared to the imperative implementation. Thanks I will take some time to understand how it works.

[Ruben Bartelink]

Also worth a scan:

https://github.com/thinkbeforecoding/FsUno.Prod 

https://github.com/bartelink/FunDomain

https://github.com/CarstenKoenig/EventSourcing
The appendix on functional event sourcing in the IDDD Red book (not definitive but a good run across the landscape)

https://vimeo.com/109343720 (deep end-to-end experience report from Leo of Jet - long but not toys or theory)

--Ruben

[Renato Cavalcanti]

For Scala, there is Fun.CQRS. 
It uses Akka and Akka Persistence as main backend. There is also a InMemoryBackend for tests and other backends implementations are possible.

www.funcqrs.io

github.com/strongtyped/fun-cqrs

Have Fun!

[Jpup]

:) Thanks

[Alexey Raga]

I did a simple example of using the EventStore in Haskell implementing a canonical DDD primer (a shopping card): https://github.com/AlexeyRaga/haskell-es-example

Regards,

Alexey.

[Michael Clark]

Lev Gorodinski (Jet.com) did an interesting port F# of the standard InventoryItem example.  It gave me a good understanding about how to utilize discriminated unions in defining Events/Commands:

https://github.com/eulerfx/DDDInventoryItemFSharp

He includes integration with EventStore as well

[Mohsen]

Take a look at this one:

https://gist.github.com/ImaginaryDevelopment/5ab93328a28349d3b12a836e7a09a0d9