The transient package

[Tags:library, mit, test]

See http://github.com/agocorona/transient Distributed primitives are in the transient-universe package. Web primitives are in the axiom package.


[Skip to Readme]

Properties

Versions 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.1.0.4, 0.1.0.8, 0.1.0.9, 0.1.1, 0.3, 0.4.0, 0.4.1, 0.4.2, 0.4.2.2, 0.4.4, 0.4.4.1, 0.5.1, 0.5.3, 0.5.4, 0.5.5, 0.5.6, 0.5.8
Change log ChangeLog.md
Dependencies base (>=4.8.1 && <5), bytestring (>=0.10.6), containers (>=0.5.6), directory (>=1.2.2), mtl, random, stm, time (>=1.5), transformers (>=0.4.2) [details]
License MIT
Author Alberto G. Corona
Maintainer agocorona@gmail.com
Category Control, Concurrency
Home page http://www.fpcomplete.com/user/agocorona
Bug tracker https://github.com/agocorona/transient/issues
Source repository head: git clone https://github.com/agocorona/transient
Uploaded Sat Jun 17 14:46:51 UTC 2017 by AlbertoCorona
Distributions LTSHaskell:0.4.4.1, NixOS:0.5.8, Stackage:0.5.8, Tumbleweed:0.4.4.1
Downloads 1323 total (191 in the last 30 days)
Votes
2 []
Status Docs available [build log]
Last success reported on 2017-06-17 [all 1 reports]
Hackage Matrix CI

Modules

[Index]

Flags

NameDescriptionDefaultType
debugEnable debugging outputsDisabledManual

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Maintainer's Corner

For package maintainers and hackage trustees

Readme for transient

Readme for transient-0.5.8

Transient logo ========= Hackage Stackage LTS Stackage Nightly Build Status Gitter NOTE: distributed computing and web primitives have been moved to transient-universe and axiom

Some feedback on transient:

  1. Rahul Muttineni @rahulmutt nov. 09 2016 03:40 Lead developper of ETA (the JVM Haskell compiler) It's a bit mind bending in that it's like using a higher-level list monad, but it's very, very cool. For beginning Haskellers, what would be really useful is a visualisation of what happens when you do various distributed/parallel stuff. It's almost shocking how effortlessly you can run computations across threads/nodes. The cool part is the composability in the distributed setting. You can make higher-order monadic functions that allow you to compose & reuse a long chain of distributed transactions via wormhole and teleport. Another benefit is that the transaction becomes first class and you can see exactly what's going on in one place instead of distributing the logic across actors making the code equivalent to event callbacks, as you've stated. https://gitter.im/Transient-Transient-Universe-HPlay/Lobby?at=58228caa35e6cf054773303b

What is Transient?

One of the dreams of software engineering is unrestricted composability. This may be put in these terms: let ap1 and ap2 two applications with arbitrary complexity, with all effects including multiple threads, asynchronous IO, indeterminism, events and perhaps, distributed computing. Then the combinations: - ap1 <|> ap2 -- Alternative expression - ap1 >>= \x -> ap2 -- monadic sequence - ap1 <> ap2 -- monoidal expression - (,) <$> ap1 <*> ap2 -- Applicative expression are possible if the types match, and generate new applications that are composable as well. Transient does exactly that. The operators <$> <*> and <> express concurrency, the operator <|> express parallelism and >>= for sequencing of threads and/or distributed processes. So even in the presence of these effects and others, everything is composable. For this purpose transient is an extensible effects monad with all major effects and primitives for parallelism, events, asynchronous IO, early termination, non-determinism logging and distributed computing. Since it is possible to extend it with more effects without adding monad transformers, the composability is assured. Documentation ============= The Wiki is more user oriented My video sessions in livecoding.tv not intended as tutorials or presentations, but show some of the latest features running. The articles are more technical: