https://guide.aelve.com/haskell/feed/category/zr69k1hc2018-09-13T21:00:55Zi6vqj1wd2018-09-13T21:00:55Z<h1> <span class="item-name">Prelude</span> (<a href="https://hackage.haskell.org/package/Prelude">Hackage</a>) </h1><p>This package provides a &quot;Prelude&quot; module drop-in replacement for <a href="https://hackage.haskell.org/package/base">base</a>'s <code>Prelude</code> module.</p> <p>Goals of this package include:</p> <ul> <li>Be reasonably modest and remain close in spirit to the <code>base</code> package's scope</li> <li>Depend only on <code>base</code> (via <code>base-noprelude</code>) for recent GHC versions</li> <li>Avoid partial functions being in scope by default; redefine common partial functions such as <code>read</code> or <code>head</code> to be <code>Maybe</code>-valued</li> <li>Provide a uniform &quot;Prelude&quot; across multiple GHC releases (currently GHC 7.0 and newer supported) to the extent possible given typeclass restructurings such as AMP or FTP</li> <li>Reduce <code>import</code> clutter by reexporting common verbs from modules such as <code>Control.Monad</code> and <code>Control.Applicative</code></li> </ul> <h2>Pros</h2><ul><p><li>Wide compatibility range extending all the way back to GHC 7.0</li></p><p><li>Minimal dependency footprint (only <code>base</code> for GHC &gt;= 8.0)</li></p></ul><h2>Cons</h2><ul></ul>ikoqdt692018-08-09T05:24:23Z<h1> <a href="https://kowainik.github.io/projects/relude" class="item-name">relude</a> (<a href="https://hackage.haskell.org/package/relude">Hackage</a>) </h1><p>Alternative to <code>Prelude</code> from <a href="https://kowainik.github.io/">@kowainik</a> (and originally from Stephen Diehl). Main design goals for <code>relude</code>:</p> <ul> <li>Type-safety and function totality</li> <li>Performance</li> <li>Convenience</li> <li>Minimalism</li> </ul> <p>See <a href="https://github.com/kowainik/relude#relude"><code>README.md</code></a> for motivation behind <code>relude</code>.</p> <h2>Pros</h2><ul><p><li><strong>Excellent documentation:</strong> Haddock with <code>doctest</code>-tested examples, tutorial, migration guide from <code>Prelude</code>.</li></p><p><li><strong>Beginner-friendly:</strong> doesn't require advanced Haskell knowledge to use it, but takes advantage of intermediate Haskell features to provide excellent performance and descriptive error messages.</li></p><p><li><strong>Efficient strings:</strong> focuses on using functions with more efficient string types like <code>Text</code> or <code>ByteString</code> instead of <code>String</code> where appropriate.</li></p><p><li><strong><em>Opt in</em> oriented:</strong> contains various extremely useful functions. But they are not exported by default to not spoil global namespace.</li></p><p><li><strong>Custom HLint rules:</strong> has <a href="https://github.com/kowainik/relude/blob/master/.hlint.yaml">custom <code>hlint</code> rules</a> that allow you to improve code quality after migration to <code>relude</code>.</li></p></ul><h2>Cons</h2><ul><p><li><strong>Medium size:</strong> <code>relude</code> is not extremely lightweight. To improve convenience, it depends on most common libraries like <code>bytestring</code>, <code>text</code>, <code>mtl</code>, <code>containers</code>, <code>unordered-containers</code>, <code>deepseq</code>, <code>stm</code>.</li></p></ul><h2>Ecosystem</h2><p><strong>Used in:</strong></p> <ul> <li><a href="https://github.com/kowainik/summoner">kowainik/summoner</a></li> <li><a href="https://github.com/kowainik/hit-on">kowainik/hit-on</a></li> <li><a href="https://github.com/kowainik/life-sync">kowainik/life-sync</a></li> <li><a href="https://github.com/holmusk/three-layer">holmusk/three-layer</a></li> <li><a href="https://github.com/rkaippully/gamgee">rkaippully/gamgee</a></li> </ul> <p>See full list here: <a href="https://packdeps.haskellers.com/reverse/relude"><code>relude</code>'s reverse dependencies</a></p> js87u2gu2018-01-18T00:04:04Z<h1> <span class="item-name">rio</span> (<a href="https://hackage.haskell.org/package/rio">Hackage</a>) </h1><h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>k0h3yvv92017-10-19T20:45:01Z<h1> <span class="item-name">papa</span> (<a href="https://hackage.haskell.org/package/papa">Hackage</a>) </h1><p>Multi-package alternative prelude. <code>papa-base</code> exports the safe and useful things in <code>base</code>. <code>papa-bifunctors</code> exports the safe and useful things in <code>bifunctors</code>. <code>papa</code> itself exports everything from all sub-packages.</p> <h2>Pros</h2><ul><p><li>Exports lots of useful functions from many libraries</li></p></ul><h2>Cons</h2><ul><p><li><code>papa</code> depends on <code>lens</code> so has a lot of dependencies</li></p></ul>qlbbk4db2017-09-27T22:28:15Z<h1> <span class="item-name">base-noprelude</span> (<a href="https://hackage.haskell.org/package/base-noprelude">Hackage</a>) </h1><p>Not actually an alternative Prelude, but rather a convenient way to define your own Prelude. It re-exports all of base except for <code>Prelude</code>.</p> <p>GHC will implicitly import the module called <code>Prelude</code>, which is usually found in the <code>base</code> package. If, however, you depend on base-noprelude rather than base and your package has a module called <code>Prelude</code>, that will be used instead, allowing you to customise it to your needs.</p> <h2>Pros</h2><ul><p><li>Assemble your own custom prelude that perfectly fits your needs.</li></p><p><li>No imports or <code>NoImplicitPrelude</code> pragmas at use sites.</li></p></ul><h2>Cons</h2><ul><p><li>Some assembly required</li></p><p><li>It's possible to make code unreadable by re-defining common names or going overboard with new combinators.</li></p></ul><h2>Ecosystem</h2><p>Designed to work out of the box with alternative <code>Prelude</code> packages such as <a href="https://hackage.haskell.org/package/Prelude">Prelude</a>.</p> <p>Could be combined with one of the actual alternative preludes with a dummy <code>Prelude.hs</code> that uses the qualified module export technique, so that you don't have to import the alt-prelude in every module.</p> ymq9gh9p2017-07-08T11:19:24Z<h1> <span class="item-name">universum</span> (<a href="https://hackage.haskell.org/package/universum">Hackage</a>) </h1><p>Custom prelude from <a href="https://github.com/serokell/">@serokell</a> team. You can checkout bigger tutorial in <a href="https://github.com/serokell/universum#universum">README.md</a>.</p> <h2>Pros</h2><ul><p><li>Maintained by company which uses Haskell in production</li></p><p><li>Reexports a lot of things you usually need in your code (<code>containers</code>, <code>transformers</code>, <code>text</code>, etc.)</li></p><p><li>Textual data type is defaulted to <code>Text</code> instead of <code>String</code></li></p><p><li>All standard <code>IO</code> functions are lifted to <code>MonadIO</code></li></p><p><li>A lot of commonly used idioms and convenient functions are introduced</li></p></ul><h2>Cons</h2><ul><p><li><code>Foldable</code> type hierarchy a little bit reimagined. You might find it unexpected when some things work for <code>Foldable</code> but doesn't work anymore when you're using <code>universum</code></li></p><p><li>Assumes medium knowledge of Haskell. It's hard to use <code>universum</code> for Haskell beginners, unfortunately.</li></p></ul><h2>Ecosystem</h2><p><a href="https://github.com/input-output-hk/cardano-sl/"><code>cardano-sl</code></a> uses <code>universum</code> as a custom prelude.</p> kbrlarbb2017-01-19T23:23:14Z<h1> <span class="item-name">SubHask</span> (<a href="https://hackage.haskell.org/package/subhask">Hackage</a>) </h1><p>From the <a href="https://github.com/mikeizbicki/subhask">README</a>:</p> <blockquote> <p>SubHask is a radical rewrite of the Haskell Prelude. The goal is to make numerical computing in Haskell fun and fast. The main idea is to use a type safe interface for programming in arbitrary subcategories of Hask. For example, the category Vect of linear functions is a subcategory of Hask, and SubHask exploits this fact to give a nice interface for linear algebra. To achieve this goal, almost every class hierarchy is redefined to be more general.</p> </blockquote> <h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>z4k1fght2017-01-16T06:03:46Z<h1> <a href="https://github.com/snoyberg/safe-prelude" class="item-name">safe-prelude</a> </h1><p>Yet another prelude by Michael Snoyman. From the <a href="https://github.com/snoyberg/safe-prelude">README</a>:</p> <blockquote> <p>A Haskell prelude optimized for safety.</p> <ul> <li> <p>No partial functions, period.</p> </li> <li> <p>Choose best in class libraries (bytestring, text, etc) and promote them.</p> </li> <li> <p>Regardless of the versions of underlying libraries, this package will always export a consistent API, so that CPP usage should be constrained to just inside this package.</p> </li> <li> <p>Use generalization (via type classes) when they are well established. For example: <code>Foldable</code> and <code>Traversable</code> yes, <code>MonoFoldable</code> no.</p> </li> <li> <p>Encourage qualified imports with a consistent naming scheme.</p> </li> <li> <p>Export any non-conflicting and not-discouraged names from this module that make sense, e.g. <code>ByteString</code>, <code>Text</code>, or <code>readIORef</code>.</p> </li> </ul> </blockquote> <h2>Pros</h2><ul></ul><h2>Cons</h2><ul><p><li>Not on Hackage yet.</li></p></ul>xl635tv62017-01-16T06:03:28Z<h1> <span class="item-name">intro</span> </h1><p>Minimal prelude which fixes pain points (Text, unsafe functions, etc) in the standard prelude.</p> <h2>Pros</h2><ul><p><li>Good support for Text over String.</li></p><p><li>Common IO functions are generalized to work in any MonadIO.</li></p><p><li>Has explicit an export list rather than exporting entire modules. This makes the Haddock documentation so much more useful.</li></p><p><li>Avoids to export unsafe functions</li></p></ul><h2>Cons</h2><ul><p><li>Does not export 'return' and many other common functions. This means it's a bit of an effort to migrate existing code to the new Prelude.</li></p></ul>cfe34g8u2016-12-27T03:42:06Z<h1> <span class="item-name">pregame</span> (<a href="https://hackage.haskell.org/package/pregame">Hackage</a>) </h1><p>A prelude for applications. Doesn't try to fix anything in Haskell, just reexports lots and lots of packages in a single module (<a href="https://hackage.haskell.org/package/aeson">aeson</a>, <a href="https://hackage.haskell.org/package/lens">lens</a>, <a href="https://hackage.haskell.org/package/data-default">data-default</a>, and so on; as well as the usual ones like <a href="https://hackage.haskell.org/package/bytestring">bytestring</a>, <a href="https://hackage.haskell.org/package/text">text</a>, <a href="https://hackage.haskell.org/package/unordered-containers">unordered-containers</a>, etc).</p> <h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>qjb4tuk22016-09-03T15:53:44Z<h1> <span class="item-name">helium-overture</span> (<a href="https://hackage.haskell.org/package/helium-overture">Hackage</a>) </h1><h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>jq1ud3vu2016-08-15T18:29:23Z<h1> <a href="http://haskell-foundation.readthedocs.io/en/latest/" class="item-name">foundation</a> (<a href="https://hackage.haskell.org/package/foundation">Hackage</a>) </h1><p>Foundation is a Haskell project to implement a modern &amp; performant standard library with various centrally maintained functionalities.</p> <p>Haskell's base has been designed a while ago and shows its age. For better or worse, it's also really hard to change base, leading to many interesting but ultimately fruitless discussions, lots of wasted efforts, and/or duplicated pieces and libraries.</p> <p>Also many core libraries, which brings lots of welcome modern additions to the language (text, bytestring, vector, &amp; many others), are maintained on the side, without coordination. For example bytestring and vector doesn't share any code.</p> <p>Foundation is trying to provide a solution to those technical and maintainance limitations.</p> <h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>our3ktbj2016-08-15T18:29:19Z<h1> <span class="item-name">preliminaries</span> (<a href="https://hackage.haskell.org/package/preliminaries">Hackage</a>) </h1><h2>Pros</h2><ul></ul><h2>Cons</h2><ul></ul>vzg6so1h2016-04-14T09:46:38Z<h1> <span class="item-name">rebase</span> (<a href="https://hackage.haskell.org/package/rebase">Hackage</a>) </h1><p>A pretty interesting prelude – it depends on lots of commonly used packages (<a href="https://hackage.haskell.org/package/containers">containers</a>, <a href="https://hackage.haskell.org/package/deepseq">deepseq</a>, <a href="https://hackage.haskell.org/package/hashable">hashable</a>, <a href="https://hackage.haskell.org/package/mtl">mtl</a>, <a href="https://hackage.haskell.org/package/text">text</a>, <a href="https://hackage.haskell.org/package/time">time</a>, <a href="https://hackage.haskell.org/package/uuid">uuid</a>, <a href="https://hackage.haskell.org/package/vector">vector</a>, and more), and makes their modules available to you via the <code>Rebase.*</code> namespace – so, for instance, instead of adding a dependency on text and importing <code>Data.Text</code> you can just import <code>Rebase.Data.Text</code> and get <code>Data.Text</code>, <code>Data.Text.IO</code> and <code>Data.Text.Encoding</code> simultaneously. This means that you save some imports <em>and</em> don't have to manually add a dependency.</p> <p>It also provides a <a href="http://hackage.haskell.org/package/rebase/docs/src/Rebase-Prelude.html"><code>Rebase.Prelude</code></a> module that reexports many non-conflicting functions and types from other modules (as well as a huge subset of base, by depending on <a href="https://hackage.haskell.org/package/base-prelude">base-prelude</a>).</p> <h2>Pros</h2><ul><p><li>Exports modules in full, not just arbitary subsets.</li></p><p><li>Shaves off more dependency declarations than other libraries.</li></p><p><li>A superset of <a href="https://hackage.haskell.org/package/base-prelude">base-prelude</a>.</li></p></ul><h2>Cons</h2><ul><p><li>The <code>Rebase.*</code> approach can seem ugly to some.</li></p></ul>b5a0ohp62016-04-14T09:46:35Z<h1> <span class="item-name">protolude</span> (<a href="https://hackage.haskell.org/package/protolude">Hackage</a>) </h1><p>A prelude by Stephen Diehl. Described <a href="http://www.stephendiehl.com/posts/protolude.html">here</a> by its author.</p> <p>Reexports:</p> <ul> <li><a href="https://hackage.haskell.org/package/base">base</a>, <a href="https://hackage.haskell.org/package/mtl">mtl</a>, <a href="https://hackage.haskell.org/package/deepseq">deepseq</a>, <a href="https://hackage.haskell.org/package/async">async</a>, <a href="https://hackage.haskell.org/package/void">void</a>, <a href="https://hackage.haskell.org/package/safe">safe</a> (safer functions for lists)</li> <li><code>Text</code>/<code>LText</code>, <code>ByteString</code>/<code>LByteString</code>, <code>Map</code>, <code>Set</code></li> <li>Some utility functions (<code>orAlt</code>, <code>ordNub</code>, <code>whenM</code>, etc)</li> <li>Rewrites functions/classes that aren't present in earlier versions of base (<code>bool</code>, <code>Bifunctor</code>, etc)</li> </ul> <p>Other things:</p> <ul> <li>Defines a class for string conversion and generalises functions like <code>show</code> and <code>print</code></li> <li>Renames <code>id</code> to <code>identity</code> (because it's convenient to be able to name variables <code>id</code>)</li> <li>Generalises <code>map</code> to <code>fmap</code>, generalises <code>head</code> to <code>Foldable</code></li> </ul> <h2>Pros</h2><ul><p><li>Exports more utility functions than other preludes.</li></p><p><li>The renaming of <code>id</code> to <code>identity</code> is nice.</li></p><p><li>Doesn't do anything radical, so you can start using it quickly.</li></p><p><li>Adds warnings to <code>trace</code>, <code>error</code> and <code>undefined</code> (so you can use them but you're constantly warned that they're still present in code).</li></p></ul><h2>Cons</h2><ul><p><li>Exports more functions than other preludes.</li></p></ul><h2>Ecosystem</h2><p><a href="https://hackage.haskell.org/package/protolude-lifted">protolude-lifted</a> – a version with reexports from <a href="https://hackage.haskell.org/package/lifted-base">lifted-base</a> and <a href="https://hackage.haskell.org/package/lifted-async">lifted-async</a> for convenient work in monads other than <code>IO</code></p> eq8b4e052016-04-14T09:46:30Z<h1> <span class="item-name">base-prelude</span> (<a href="https://hackage.haskell.org/package/base-prelude">Hackage</a>) </h1><p>A single module reexporting most definitions in <a href="https://hackage.haskell.org/package/base">base</a>. Doesn't serve any purpose other than reducing the number of imports, but is still pretty useful. (For me it routinely shaves off 5–10 imports.)</p> <h2>Pros</h2><ul><p><li>You don't have to learn any new functions, or, well, <em>anything</em>. Just plug it in and enjoy not having to import things.</li></p><p><li>Doesn't incur any dependencies.</li></p></ul><h2>Cons</h2><ul><p><li>Doesn't help with other commonly needed packages (such as <a href="https://hackage.haskell.org/package/text">text</a>, <a href="https://hackage.haskell.org/package/vector">vector</a>, etc).</li></p></ul><h2>Ecosystem</h2><p><a href="https://hackage.haskell.org/package/rebase">rebase</a> – uses base-prelude and exports lots of additional modules</p> x8fl6eog2016-04-14T09:46:16Z<h1> <span class="item-name">basic-prelude</span> (<a href="https://hackage.haskell.org/package/basic-prelude">Hackage</a>) </h1><p>A “foundation” prelude by the author of <a href="https://hackage.haskell.org/package/classy-prelude">classy-prelude</a>. Exports two modules – <code>CorePrelude</code> (intended for developers who want to make their own prelude), and <code>BasicPrelude</code> (a simple prelude for users, built on <code>CorePrelude</code>).</p> <p><a href="https://hackage.haskell.org/package/basic-prelude/docs/CorePrelude.html"><code>CorePrelude</code></a> reexports:</p> <ul> <li>commonly used functions from <code>Prelude</code> and other base modules</li> <li>types (the usual bunch – <code>Map</code>, <code>Vector</code>, <code>HashMap</code>, <code>ByteString</code>, <code>Text</code>, etc)</li> <li>a selection of functions from other packages (<code>lift</code> and <code>liftIO</code>, <code>&lt;/&gt;</code> and <code>&lt;.&gt;</code>, as well as hashing functions from <a href="https://hackage.haskell.org/package/hashable">hashable</a>, functions for catching exceptions from <a href="https://hackage.haskell.org/package/lifted-base">lifted-base</a>, and <code>readArgs</code> from <a href="https://hackage.haskell.org/package/ReadArgs">ReadArgs</a>, a very simple parser for command line arguments)</li> </ul> <p>It also reimplements functions like <code>putStrLn</code> and <code>print</code> for <code>Text</code>, and a small number of utility functions (<code>bool</code>, <code>equating</code>).</p> <p><a href="https://hackage.haskell.org/package/basic-prelude/docs/BasicPrelude.html"><code>BasicPrelude</code></a>, additionally:</p> <ul> <li>reexports <code>Control.Monad</code>, methods of <code>Foldable</code> and <code>Traversable</code>, some functions from <code>Data.List</code></li> <li>generalises <code>++</code>, <code>concat</code>, and <code>map</code></li> <li>replaces <code>read</code>, <code>show</code>, <code>readFile</code>, etc with their <code>Text</code>-based equivalents</li> </ul> <h2>Pros</h2><ul><p><li>Exports functions from <a href="https://hackage.haskell.org/package/filepath">filepath</a> and <a href="https://hackage.haskell.org/package/hashable">hashable</a>, which many other preludes don't do.</li></p></ul><h2>Cons</h2><ul><p><li>Doesn't export <code>&amp;</code>.</li></p><p><li>Focuses on <code>Text</code>, so can be annoying if you use many libraries that need <code>String</code>.</li></p><p><li>Only reimplements a few functions for compatibility with older versions of base (other preludes reimplement more).</li></p><p><li>Feels somewhat opinionated (why <a href="https://hackage.haskell.org/package/hashable">hashable</a> and <a href="https://hackage.haskell.org/package/ReadArgs">ReadArgs</a> but not more commonly used libraries like <a href="https://hackage.haskell.org/package/deepseq">deepseq</a> or <a href="https://hackage.haskell.org/package/mtl">mtl</a>? etc).</li></p></ul>elrtmfyb2016-04-14T09:46:12Z<h1> <span class="item-name">classy-prelude</span> (<a href="https://hackage.haskell.org/package/classy-prelude">Hackage</a>) </h1><p>A prelude that defines lots of ad-hoc typeclasses (e.g. there's <code>IsMap</code> with methods like <code>lookup</code>, <code>insertMap</code>, etc) and thus removes the need for most qualified imports.</p> <p>It also defines some utility functions (<code>whenM</code>, etc) and reexports lots of commonly used modules (from <a href="https://hackage.haskell.org/package/time">time</a>, <a href="https://hackage.haskell.org/package/mtl">mtl</a>, and so on).</p> <h2>Pros</h2><ul><p><li>Marks <code>undefined</code> as deprecated (so you'll know if you've accidentally left it in code).</li></p><p><li>Goes further than other preludes in removing boilerplate like qualified names, etc.</li></p></ul><h2>Cons</h2><ul><p><li>Some people dislike ad-hoc typeclasses.</li></p><p><li>Without qualified names it's hard to understand what type you're operating on.</li></p><p><li>Error messages can be scary.</li></p></ul><h2>Ecosystem</h2><p><a href="https://hackage.haskell.org/package/classy-prelude-conduit">classy-prelude-conduit</a>, <a href="https://hackage.haskell.org/package/classy-prelude-yesod">classy-prelude-yesod</a></p>