these alternatives and similar packages
Based on the "Control" category.
Alternatively, view these alternatives based on common mentions on social networks and blogs.

transient
A full stack, reactive architecture for general purpose programming. Algebraic and monadically composable primitives for concurrency, parallelism, event handling, transactions, multithreading, Web, and distributed computing with complete deinversion of control (No callbacks, no blocking, pure state) 
distributedclosure
Serializable closures for distributed programming. 
classyprelude
Type classes for mapping, folding, and traversing monomorphic containers 
classypreludeyesod
Type classes for mapping, folding, and traversing monomorphic containers 
auto
Haskell DSL and platform providing denotational, compositional api for discretestep, locally stateful, interactive programs, games & automations. http://hackage.haskell.org/package/auto 
selective
Selective Applicative Functors: Declare Your Effects Statically, Select Which to Execute Dynamically 
extensibleeffects
Extensible Effects: An Alternative to Monad Transformers 
ComonadSheet
A library for expressing "spreadsheetlike" computations with absolute and relative references, using fixedpoints of ndimensional comonads. 
abstractpar
Type classes generalizing the functionality of the 'monadpar' library. 
hask
Category theory for Haskell with a lens flavor (you need GHC 7.8.3, not 7.8.2 to build this!) 
transientuniverse
A Cloud monad based on transient for the creation of Web and reactive distributed applications that are fully composable, where Web browsers are first class nodes in the cloud 
cloudhaskell
This is an umbrella development repository for Cloud Haskell 
distributedprocessplatform
DEPRECATED (Cloud Haskell Platform) in favor of distributedprocessextras, distributedprocessasync, distributedprocessclientserver, distributedprocessregistry, distributedprocesssupervisor, distributedprocesstask and distributedprocessexecution 
distributedfork
A distributed data processing framework in Haskell. 
monadvalidate
(NOTE: REPOSITORY MOVED TO NEW OWNER: https://github.com/lexilambda/monadvalidate) A Haskell monad transformer library for data validation 
ixmonad
Provides 'graded monads' and 'parameterised monads' to Haskell, enabling finegrained reasoning about effects. 
freereffects
An implementation of "Freer Monads, More Extensible Effects". 
monadcontrol
Lift control operations, like exception catching, through monad transformers 
effectmonad
Provides 'graded monads' and 'parameterised monads' to Haskell, enabling finegrained reasoning about effects. 
monadtime
Type class for monads which carry the notion of the current time. 
operational
Implement monads by specifying instructions and their desired operational semantics.
Truly a developer’s best friend
Do you think we are missing an alternative of these or a related project?
README
These — an eitherorboth data type
The type These a b
represents having either a value of type a
, a value of type b
, or values of both a
and b
:
data These a b = This a  That b  These a b
This is equivalent to Either (a, b) (Either a b)
. Or equivalent to Either a (b, Maybe a)
. Or various other equally equivalent types. In terms of "sum" and "product" types, These a b
is a + b + ab
which can't be factored cleanly to get a type that mentions a
and b
only once each.
The fact that there's no single obvious way to express it as a combination of existing types is one primary motivation for this package.
A variety of functions are provided in Data.These
akin to those in Data.Either
, except somewhat more numerous on account of having more cases to consider. Most should be selfexplanatory if you're already familiar with the similarlynamed functions in Data.Either
and Data.Maybe
.
here
and there
are traversals over elements of the same type, suitable for use with Control.Lens
. This has the dramatic benefit that if you're using lens
you can ignore the dreadfully bland mapThis
and mapThat
functions in favor of saying over here
and over there
.
Align — structural unions
There is a notion of "zippy" Applicative
s where liftA2 (,)
behaves like zip
in the sense that if the Functor
is regarded as a container with distinct locations, each element of the result is a pair of the values that occupied the same location in the two inputs. For this to be possible, the result can only contain values at locations where both inputs also contained values. In a sense, this is the intersection of the "shapes" of the two inputs.
In the case of the zip
function itself, this means the length of the result is equal to the length of the shorter of the two inputs.
On many occasions it would be more useful to have a "zip with padding", where the length of the result is that of the longer input, with the other input extended by some means. The best way to do this is a recurring question, having been asked at least four times on Stack Overflow.
Probably the most obvious generalpurpose solution is use Maybe
so that the result is of type [(Maybe a, Maybe b)]
, but this forces any code using that result to consider the possibility of the list containing the value (Nothing, Nothing)
, which we don't want.
The type class Align
is here because f (These a b)
is the natural result type of a generic "zip with padding" operationi.e. a structural union rather than intersection.
I believe the name "Align" was borrowed from a blog post by Paul Chiusano, though he used Alignable
instead.
Unalign
unalign
is to align
as unzip
is to zip
. The Unalign
class itself does nothing, as unalign
can be defined for any Functor
; an instance just documents that unalign
behaves properly as an inverse to align
.
Crosswalk
Crosswalk
is to Align
as Traversable
is to Applicative
. That's really all there is to say on the matter.
Bicrosswalk
<cmccann> elliott, you should think of some more instances for Bicrosswalk one of these days
<shachaf> cmccann: Does it have any instances?
<elliott> cmccann: unfortunately it is too perfect an abstraction to be useful.
ChronicleT — a.k.a. These as a monad
These a
has an obvious Monad
instance, provided here in monad transformer form.
The expected use case is for computations with a notion of fatal vs. nonfatal errors, like a hybrid writer/exception monad. While running successfully a computation carries a "record" of type c
, which accumulates using a Monoid
instance (as with the writer monad); if a computation fails completely, the result is its record up to the point where it ended.
A more specific example would be something like parsing illformed input with the goal of extracting as much as you can and throwing out anything you can't interpret.