`:set -XRankNTypes`. The `-X` part is a compiler switch, by the way, extension is called just `RankNTypes`.

I&#39;m having some problems installing [vows](http://vowsjs.org) via npm in zsh. Here&#39;s what I get. I tried installing it with and without the -g option. Do you have any idea what&#39;s wrong here?

    [❤  ~/Desktop/sauce-node-demo:master] npm install -g vows
    npm http GET https://registry.npmjs.org/vows
    npm http 304 https://registry.npmjs.org/vows
    npm http GET https://registry.npmjs.org/eyes
    npm http GET https://registry.npmjs.org/diff
    npm http 304 https://registry.npmjs.org/eyes
    npm http 304 https://registry.npmjs.org/diff
    /usr/local/share/npm/bin/vows -&gt; /usr/local/share/npm/lib/node_modules/vows/bin/vows
    vows@0.6.4 /usr/local/share/npm/lib/node_modules/vows
    ├── eyes@0.1.8
    └── diff@1.0.3
    [❤  ~/Desktop/sauce-node-demo:master] vows
    zsh: command not found: vows


Thanks

Command not found after npm install in zsh

**How do I break out of an [parallel.for][1] loop?**

I have a pretty complex statement which looks like the following: 

    Parallel.ForEach&lt;ColorIndexHolder&gt;(ColorIndex.AsEnumerable(),
        new Action&lt;ColorIndexHolder&gt;((ColorIndexHolder Element) =&gt;
        {
            if (Element.StartIndex &lt;= I &amp;&amp; Element.StartIndex + Element.Length &gt;= I)
            {
                Found = true;
                break;
            }
        }));


Using parallel class, I can optimize this process by far. However; I cannot figure out how to break the parallel loop? The `break;` statement throws following syntax error: 

&gt; No enclosing loops out of which to break or continue

  [1]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.parallel.for.aspx

Break parallel.foreach?

I&#39;m trying to enable `XRankNTypes` in GHCi.  How do I do this?

How do I enable language extensions from within GHCi?

<p>I'm trying to enable <code>XRankNTypes</code> in GHCi.  How do I do this?</p>


GHC has a lot of optimizations that it can perform, but I don&#39;t know what they all are, nor how likely they are to be performed and under what circumstances.

My question is: what transformations can I expect it to apply every time, or nearly so? If I look at a piece of code that&#39;s going to be executed (evaluated) frequently and my first thought is &quot;hmm, maybe I should optimize that&quot;, in which cases should my second thought be, &quot;don&#39;t even think about it, GHC got this&quot;?

I was reading the paper [Stream Fusion: From Lists to Streams to Nothing at All][1], and the technique they used of rewriting list processing into a different form which GHC&#39;s normal optimizations would then reliably optimize down into simple loops was novel to me. How can I tell when my own programs are eligible for that kind of optimization?

There&#39;s [some information][2] in the GHC manual, but it only goes part of the way towards answering the question.

EDIT: I&#39;m starting a bounty. What I would like is a list of lower-level transformations like lambda/let/case-floating, type/constructor/function argument specialization, strictness analysis and unboxing, worker/wrapper, and whatever else significant GHC does that I&#39;ve left out, along with explanations and examples of input and output code, and ideally illustrations of situations when the total effect is more than the sum of its parts. And ideally some mention of when transformations *won&#39;t* happen. I&#39;m not expecting novel-length explanations of every transformation, a couple of sentences and inline one-liner code examples could be enough (or a link, if it&#39;s not to twenty pages of scientific paper), as long as the big picture is clear by the end of it. I want to be able to look at a piece of code and be able to make a good guess about whether it will compile down to a tight loop, or why not, or what I would have to change to make it. (I&#39;m not interested so much here in the big optimization frameworks like stream fusion (I just read a paper about that); more in the kind of knowledge that people who *write* these frameworks have.)

[1]: http://metagraph.org/papers/stream_fusion.pdf
[2]: http://www.haskell.org/ghc/docs/latest/html/users_guide/options-optimise.html

What optimizations can GHC be expected to perform reliably?

While reading https://en.uncyclopedia.co/wiki/Haskell (and ignoring all the &quot;offensive&quot; stuff), I stumbled upon the following piece of obfuscated code:

    fix$(&lt;$&gt;)&lt;$&gt;(:)&lt;*&gt;((&lt;$&gt;((:[{- thor&#39;s mother -}])&lt;$&gt;))(=&lt;&lt;)&lt;$&gt;(*)&lt;$&gt;(*2))$1

When I run that piece of code in `ghci` (after importing `Data.Function` and `Control.Applicative`), `ghci` prints the list of all powers of 2.

How does this piece of code work?

How does this piece of obfuscated Haskell code work?

Haskell has a magical function named `seq`, which takes an argument of any type and reduces it to *Weak Head Normal Form* (WHNF).

I&#39;ve read a couple of sources [not that I can remember who they were _now_...] which claim that &quot;polymorphic `seq` is bad&quot;. In what way are they &quot;bad&quot;?

Similarly, there is the `rnf` function, which reduces an argument to *Normal Form* (NF). But _this_ is a class method; it does not work for arbitrary types. It seems &quot;obvious&quot; to me that one could alter the language spec to provide this as a built-in primitive, similar to `seq`. This, presumably, would be &quot;even more bad&quot; than just having `seq`. In what way is this so?

Finally, somebody suggested that giving `seq`, `rnf`, `par` and similars the same type as the `id` function, rather than the `const` function as it is now, would be an improvement. How so?


Why is seq bad?

Eeek!  GHCi found Skolems in my code!

    ...
    Couldn&#39;t match type `k0&#39; with `b&#39;
      because type variable `b&#39; would escape its scope
    This (rigid, skolem) type variable is bound by
      the type signature for
        groupBy :: Ord b =&gt; (a -&gt; b) -&gt; Set a -&gt; Set (b, [a])
    The following variables have types that mention k0
    ...

What are they?  What do they want with my program?
And why are they trying to escape (the ungrateful little blighters)?

What are skolems?

I have seen several sources echo the opinion that &quot;Haskell is gradually becoming a dependently-typed language&quot;. The implication seems to be that with more and more language extensions, Haskell is drifting in that general direction, but isn&#39;t there yet.

There are basically two things I would like to know. The first is, quite simply, what does &quot;being a dependently-typed language&quot; actually _mean_? (Hopefully without being too technical about it.)

The second question is... what&#39;s the drawback? I mean, people know we&#39;re heading that way, so there must be some advantage to it. And yet, we&#39;re not there yet, so there must be some downside stopping people going all the way. I get the impression that the problem is a steep increase in complexity. But, not really understanding what dependent typing is, I don&#39;t know for sure.

What I _do_ know is that every time I start reading about a dependently-typed programming language, the text is utterly incomprehensible... Presumably that&#39;s the problem. (?)


Why not be dependently typed?

I&#39;m trying to make the types ghci displays for my libraries as intuitive as possible, but I&#39;m running into a lot of difficulties when using more advanced type features.

Let&#39;s say I have this code in a file:

    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE TypeOperators #-}
    
    import GHC.TypeLits
    
    data Container (xs::[*]) = Container

I load it up in ghci, then I type the following command:

    ghci&gt; :t undefined :: Container &#39;[String,String,String,String,String]

Unfortunately, ghci gives me the rather ugly looking:

    :: Container
           ((&#39;:)
              *
              String
              ((&#39;:)
                 * String ((&#39;:) * String ((&#39;:) * String ((&#39;:) * String (&#39;[] *))))))
    
ghci has removed the sugar for type level strings.  Is there any way to prevent ghci from doing this and giving me just the pretty version?

----

On a related note, lets say I create a type level `Replicate` function 
    
    data Nat1 = Zero | Succ Nat1
    
    type family Replicate (n::Nat1) x :: [*]
    type instance Replicate Zero x = &#39;[]
    type instance Replicate (Succ n) x = x &#39;: (Replicate n x)

    type LotsOfStrings = Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String

Now, when I ask ghci for a type using `LotsOfStrings`:

    ghci&gt; :t undefined :: Container LotsOfStrings

ghci is nice and gives me the pretty result:

    undefined :: Container LotsOfStrings

But if I ask for the `Replicate`d version,

    ghci&gt; :t undefined :: Container (Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String)

ghci substitutes in for the type family when it didn&#39;t do that for the type synonym:

    :: Container
           ((&#39;:)
              *
              [Char]
              ((&#39;:)
                 * [Char] ((&#39;:) * [Char] ((&#39;:) * [Char] ((&#39;:) * [Char] (&#39;[] *))))))

Why is ghci doing the substitution for the type family, but not the type synonym?  Is there a way to control when ghci will do the substitution?

Why does ghci desugar type lists and type families? Can this be selectively disabled?

I encounter a strange situation in *GHCI*, don&#39;t know if anyone observed similar case. For some module, when I have it in the search path both by `-package-conf`, and also by `-i`, GHCI fails when I try to import the module with `&#39;module is not loaded: FooModule&#39;`.

 - `:module` loads it fine however
 - or I can do `:load FooModule`, `:m` to clear the import list, and then `import FooModule`
 - or I can remove the path from `-i` and then it imports fine

Tracked this to be the `otherwise -&gt; modNotLoadedError m loc` case in [GHC][1], where `otherwise` ~ `modulePackageId = this_pkg` (the meaning of which I don&#39;t know).

This is not entirely systematic, there are some module which are both in package and source path, but can be imported.



  [1]: http://www.haskell.org/ghc/docs/7.4.1/html/libraries/ghc/src/GHC.html

GHCI can&#39;t load module if both package-conf and source path contains it

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

I saw a program in C that had code like the following:

    static void *arr[1]  = {&amp;&amp; varOne,&amp;&amp; varTwo,&amp;&amp; varThree};

    varOne: printf(&quot;One&quot;) ;
    varTwo: printf(&quot;Two&quot;) ;
    varThree: printf(&quot;Three&quot;) ;


I am confused about what the `&amp;&amp;` does because there is nothing to the left of it. Does it evaluate as null by default? Or is this a special case?

Edit: 
Added some more information to make the question/code more clear for my question.
Thank you all for the help. This was a case of the gcc specific extension.

Content Type	Original Author	Original Content on Stackoverflow
Question	Matt Fenwick	View Question on Stackoverflow
Solution 1 - Haskell	Cat Plus Plus	View Answer on Stackoverflow

How do I enable language extensions from within GHCi?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Break parallel.foreach?

Command not found after npm install in zsh

Attributions