Cabal doesn&#39;t keep track of what it&#39;s installed, it just uses ghc&#39;s library mechanism (or that of some other compiler if you&#39;re not using ghc), so you can use `rm -r ~/.ghc` to remove all locally-installed libraries.

If you have multiple ghc&#39;s installed, and you only want to remove the libs for a specific ghc, delete the subdirectory corresponding to whichever ghc you want to remove.  
For example, I could remove everything I&#39;ve installed for ghc-7.6.0 with `rm -r ~/.ghc/x86_64-linux-7.6.0.20120810`  
You can also use this to preserve your ghci_history if you like.

    ll ~/.ghc/
    total 24
    -rw-r--r-- 1 johnl johnl 2300 Aug 21 11:47 ghci_history
    drwxr-xr-x 3 johnl johnl 4096 Jun 17 19:09 x86_64-linux-6.12.3
    drwxr-xr-x 3 johnl johnl 4096 May 17 08:17 x86_64-linux-7.2.1
    drwxr-xr-x 3 johnl johnl 4096 May 16 17:34 x86_64-linux-7.4.1
    drwxr-xr-x 3 johnl johnl 4096 Jun 15 08:21 x86_64-linux-7.4.2
    drwxrwxr-x 3 johnl johnl 4096 Aug 15 12:37 x86_64-linux-7.6.0.20120810

Edit: `~/.cabal/world` is a list of installed packages with version constraints as specified by the user.  So in most cases, it would include e.g. `mtl -any`.  If you&#39;ve installed packages with specific versions, such as by issuing `cabal install mtl-2.1.1`, it will record that version.  You should be able to either delete the world file and start over, or if you look it over and the dependencies are acceptable, you could try just running `cabal install world`. Or you could ignore it and not use cabal&#39;s world support (that&#39;s what I do).

This [ghc-pkg-reset](https://gist.github.com/1185421) shell script cleans both ~/.ghc/ and ~/.cabal/, a little more selectively. (And the accompanying ghc-pkg-clean script can help recover from a confused package installation, perhaps avoiding a reset.) I find these useful.

I have a string. The end is different, such as `index.php?test=1&amp;list=UL` or `index.php?list=UL&amp;more=1`. The one thing I&#39;m looking for is `&amp;list=`.

How can I match it, whether it&#39;s in the middle of the string or it&#39;s at the end? So far I&#39;ve got `[&amp;|\?]list=.*?([&amp;|$])`, but the `([&amp;|$])` part doesn&#39;t actually work; I&#39;m trying to use that to match either `&amp;` or the end of the string, but the end of the string part doesn&#39;t work, so this pattern matches the second example but not the first.

In regex, match either the end of the string or a specific character

I have JSON in the following format:

    [
        {&quot;id&quot;:&quot;10&quot;,&quot;name&quot;:&quot;User&quot;,&quot;add&quot;:false,&quot;edit&quot;:true,&quot;authorize&quot;:true,&quot;view&quot;:true},
        {&quot;id&quot;:&quot;11&quot;,&quot;name&quot;:&quot;Group&quot;,&quot;add&quot;:true,&quot;edit&quot;:false,&quot;authorize&quot;:false,&quot;view&quot;:true},
        {&quot;id&quot;:&quot;12&quot;,&quot;name&quot;:&quot;Permission&quot;,&quot;add&quot;:true,&quot;edit&quot;:true,&quot;authorize&quot;:true,&quot;view&quot;:true}
    ]

How can I convert that into a C# `DataTable` object as follows?

    ---------------------------------------------------------------------
    ID    |  Name     |  Add    |   Edit  | View   | Authorize
    ---------------------------------------------------------------------
    10    | User      | true    |  true   | true   |  true
    11    | Group     | true    |  true   | true   |  true
    12    | Permission| true    |  true   | true   |  true

Convert JSON to DataTable

I forgot to enable building libs for profiling in my `~/.cabal/config` before installing a bunch of packages on a new machine and now a `--reinstall world` to try to fix the situation has left everything broken (naturally). 

I think it&#39;s a better use of my time to just purge everything. How do I do that correctly?

My cabal packages are FUBAR; how can I purge them and start over?

<p>I forgot to enable building libs for profiling in my <code>~/.cabal/config</code> before installing a bunch of packages on a new machine and now a <code>--reinstall world</code> to try to fix the situation has left everything broken (naturally).</p>
<p>I think it's a better use of my time to just purge everything. How do I do that correctly?</p>


I was looking around stackoverflow [Non-Trivial Lazy Evaluation][1], which led me to Keegan McAllister&#39;s presentation: [Why learn Haskell][2]. In slide 8, he shows the minimum function, defined as:

    minimum = head . sort

and states that its complexity is O(n). I don&#39;t understand why the complexity is said to be linear if sorting by replacement is O(nlog n). The sorting referred in the post can&#39;t be linear, as it does not assume anything about the data, as it would be required by linear sorting methods, such as counting sort.

Is lazy evaluation playing a mysterious role in here? If so, what is the explanation behind it?


  [1]: https://stackoverflow.com/questions/7868507/non-trivial-lazy-evaluation
  [2]: http://ugcs.net/~keegan/talks/why-learn-haskell/talk.pdf

Lazy Evaluation and Time Complexity

If you [declare a library + executable sections in a cabal file while avoiding double compilation of the library](https://stackoverflow.com/questions/6711151/how-to-avoid-recompiling-in-this-cabal-file/6711739) by putting the library into a `hs-source-dirs` directory, you cannot usually run your project with `ghci` and `runhaskell` anymore, especially if the executables have helper modules themselves.

What is a recommended project layout that

* only builds what is needed once
* allows using `runhaskell`
* has a clean structure without hacks?

How to make a Haskell cabal project with library+executables that still run with runhaskell/ghci?

I realize that this could potentially be considered a subjective or maybe an off-topic question, so I hope that rather than have it closed it would get migrated, maybe to Programmers.

I&#39;m starting to learn Haskell, mostly for my own edification, and I like a lot of the ideas and principles backing the language.  I became fascinated with functional languages after taking a language theory class where we played around with Lisp, and I had been hearing a lot of good things about how productive Haskell could be, so I figured I&#39;d investigate it myself.  So far, I like the language, except for one thing that I can&#39;t just get away from: Those mother effing function signatures.

My professional background is mostly doing OO, especially in Java.  Most of the places that I&#39;ve worked for have hammered in a lot of the standard modern dogmas; Agile, Clean Code, TDD, etc.  After a few years of working this way, It has definitely become my comfort zone; especially the idea that &quot;good&quot; code should be self documenting.  I&#39;ve become used to working in an IDE, where long and verbose method names with very descriptive signatures are a non-issue with intelligent auto completion and a huge array of analytical tools for navigating packages and symbols; if I can hit Ctrl+Space in Eclipse, then deduce what a method is doing from looking at its name and the locally scoped variables associated with its arguments instead of pulling up the JavaDocs, I&#39;m as happy as a pig in poop.

This is, decidedly, not part of the community best practices in Haskell.  I&#39;ve read through plenty of different opinions on the matter, and I understand that the Haskell community considers its succinctness to be a &quot;pro&quot;.  I&#39;ve gone through [How To Read Haskell](http://www.haskell.org/haskellwiki/How_to_read_Haskell#General_advice), and I understand the rationale behind a lot of the decisions, but it doesn&#39;t mean that I like them; one letter variable names, etc. aren&#39;t fun for me.  I acknowledge that I&#39;ll have to get used to that if I want to keep hacking with the language.

But I can&#39;t get over the function signatures.  Take this example, as pulled from [Learn you a Haskell[...]](http://learnyouahaskell.com/syntax-in-functions)&#39;s section on function syntax:

    bmiTell :: (RealFloat a) =&gt; a -&gt; a -&gt; String  
    bmiTell weight height  
        | weight / height ^ 2 &lt;= 18.5 = &quot;You&#39;re underweight, you emo, you!&quot;  
        | weight / height ^ 2 &lt;= 25.0 = &quot;You&#39;re supposedly normal. Pffft, I bet you&#39;re ugly!&quot;  
        | weight / height ^ 2 &lt;= 30.0 = &quot;You&#39;re fat! Lose some weight, fatty!&quot;  
        | otherwise                   = &quot;You&#39;re a whale, congratulations!&quot;

I realize that this is a silly example that was only created for the purpose of explaining guards and class constraints, but if you were to examine *just* the signature of that function, you would have no idea which of its arguments was intended to be the weight or the height.  Even if you were to use `Float` or `Double` instead of any type, it would still not be immediately discernible.

At first, I thought I would be cute and clever and brilliant and try to spoof it using longer type variable names with multiple class constraints:

    bmiTell :: (RealFloat weight, RealFloat height) =&gt; weight -&gt; height -&gt; String

This spat out an error (as an aside, if anyone can explain the error to me, I&#39;d be grateful):

    Could not deduce (height ~ weight)
        from the context (RealFloat weight, RealFloat height)
          bound by the type signature for
                     bmiTell :: (RealFloat weight, RealFloat height) =&gt;
                                weight -&gt; height -&gt; String
          at example.hs:(25,1)-(27,27)
          `height&#39; is a rigid type variable bound by
                   the type signature for
                     bmiTell :: (RealFloat weight, RealFloat height) =&gt;
                                weight -&gt; height -&gt; String
                   at example.hs:25:1
          `weight&#39; is a rigid type variable bound by
                   the type signature for
                     bmiTell :: (RealFloat weight, RealFloat height) =&gt;
                                weight -&gt; height -&gt; String
                   at example.hs:25:1
        In the first argument of `(^)&#39;, namely `height&#39;
        In the second argument of `(/)&#39;, namely `height ^ 2&#39;
        In the first argument of `(&lt;=)&#39;, namely `weight / height ^ 2&#39;

Not understanding completely why that didn&#39;t work, I started Googling around, and I even found this little post that suggests named parameters, specifically, [spoofing named parameters via `newtype`](http://blog.ezyang.com/2010/09/keyword-arguments-in-haskell/), but that seems to be a bit much.

Is there no acceptable way to craft informative function signatures?  Is &quot;The Haskell Way&quot; simply to Haddock the crap out of everything?

Is there a nice way to make function signatures more informative in Haskell?

I understand that the ST monad is something like a little brother of IO, which in turn is the state monad with added `RealWorld` magic. I can picture states and I can picture that RealWorld is somehow put into IO, but every time I write a type signature of `ST` the `s` of the ST monad confuses me. 

Take, for example, `ST s (STArray s a b)`. How does the `s` work there? Is it just used to build up some artificial data dependency between computations without being able to be referenced like states in the state monad (due to the `forall`)?

I&#39;m just throwing out ideas and would really appreciate someone more knowledgeable than I to explain it to me.

How does the ST monad work?

I _swear_ there used to be a **T-shirt** for sale featuring the immortal words:

---

What part of

![Hindley-Milner][1]

  [1]: https://i.stack.imgur.com/xkKgE.png

do you _not_ understand?

---

In my case, the answer would be... all of it!

In particular, I often see notation like this in Haskell papers, but I have no clue what any of it means. I have no idea what branch of mathematics it&#39;s supposed to be.

I recognize the letters of the Greek alphabet of course and symbols such as &quot;∉&quot; (which usually means that something is not an element of a set).

On the other hand, I&#39;ve never seen &quot;⊢&quot; before ([Wikipedia claims it might mean &quot;partition&quot;][wiki]). I&#39;m also unfamiliar with the use of the vinculum here. (Usually, it denotes a fraction, but that does not _appear_ to be the case here.)

If somebody could at least tell me where to start looking to comprehend what this sea of symbols means, that would be helpful.

[wiki]:https://en.wikipedia.org/wiki/List_of_mathematical_symbols



What part of Hindley-Milner do you not understand?

Yesterday I learnt about a new Haskell tool called [Stack][1]. At the first blush, it looks like it does much the same job as Cabal. So, what is the difference between them? Is stack a replacement for Cabal? In which cases should I use Stack instead of Cabal? What can Stack do that Cabal can&#39;t?


  [1]: https://github.com/commercialhaskell/stack

What is the difference between Cabal and Stack?

Using cabal, I could install hakyll with the command:

    cabal install hakyll

How can I do the same thing using stack?

How to install a package using stack?

I&#39;m running into odd behavior with the Interactive-Haskell repl in `emacs`. When I source a file, the `emacs` mini buffer shows a series of interactive prompts:

    Start a new project named &#39;myproject&#39;?
    Cabal dir (guessed from myproject.cabal):
    Build target (empty for default):
    Set current directory:

If I leave either the cabal directory or the current directory to the default value of the project directory, the repl is unresponsive. I get a lambda prompt in the interactive Haskell window, I can type, but when I press enter, it never evaluates. The cursor stays on the same line as if I did not press enter at all. 

If I change both of those directories to some path other than my project directory, then the repl behaves normally and evaluates expressions as expected.


Emacs Interactive-Haskell repl non-response if either the cabal or working directory set to project directory

How do I tell `stack` to build my executable and all its dependencies with `-prof`? 

Simply adding it to `ghc-options` in the `.cabal` file is not enough, because it only tries to build the executable with profiling enabled, which fails.

Content Type	Original Author	Original Content on Stackoverflow
Question	jberryman	View Question on Stackoverflow
Solution 1 - Haskell	John L	View Answer on Stackoverflow
Solution 2 - Haskell	Simon Michael	View Answer on Stackoverflow

My cabal packages are FUBAR; how can I purge them and start over?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Convert JSON to DataTable

In regex, match either the end of the string or a specific character

Attributions