You can pass the argument to ghc from ghc-mod as:

    $ ghc-mod lint *.hs -g -dsuppress-module-prefixes

This will send the argument `-dsuppress-module-prefixes` to ghc.

You can try passing `-dsuppress-module-prefixes` as a GHC option. At some point, it did help me to get rid of module qualifiers in names.

This is the code from the C++ standard library `remove` code. Why is inequality tested as `if (!(*first == val))` instead of `if (*first != val)`?

     template &lt;class ForwardIterator, class T&gt;
          ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T&amp; val)
     {
         ForwardIterator result = first;
         while (first!=last) {
             if (!(*first == val)) {
                 *result = *first;
                 ++result;
             }
             ++first;
         }
         return result;
     }



Why is inequality tested as (!(a==b)) in a lot of C++ standard library code?

Is there a more concise and less error-prone way in PowerShell to check if a path DOES NOT exist?

This is objectively too verbose for such a common use case:

    if (-not (Test-Path $path)) { ... }
    if (!(Test-Path $path)) { ... }

It needs too many parenthesis and is not very readable when checking for &quot;not exist&quot;. It&#39;s also error-prone because a statement like:

    if (-not $non_existent_path | Test-Path) { $true } else { $false }

will actually return `False`, when the user may expect `True`.

What is a better way to do this?

**Update 1:** My current solution is to use aliases for `exist` and `not-exist` as explained [here](https://stackoverflow.com/a/31888581/450913).

**Update 2:** A proposed syntax that will also fix this is to allow the following grammar:

    if !(expr) { statements* }
    if -not (expr) { statements* }

Here&#39;s the related issue in PowerShell repository (please vote up &#128077;): https://github.com/PowerShell/PowerShell/issues/1970


A better way to check if a path exists or not in PowerShell

I&#39;m trying to use the `ghc-mod` vim plugin to do type/syntax checking etc. However, I found that `ghc-mod` always uses full paths of types in the error messages, for example:

    test.hs|71 col 13 error| Couldn&#39;t match type ‘Data.Text.Internal.Text’                                                                                   
    ||                with ‘[GHC.Types.Char]’
    || Expected type: containers-0.5.6.2:Data.Map.Base.Map
    ||                  [GHC.Types.Char]
    ||                  ([(integer-gmp-1.0.0.0:GHC.Integer.Type.Integer,
    ||                     integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)],
    ||                   containers-0.5.6.2:Data.Set.Base.Set
    ||                     integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)
    ||   Actual type: containers-0.5.6.2:Data.Map.Base.Map
    ||                  Data.Text.Internal.Text
    ||                  ([(integer-gmp-1.0.0.0:GHC.Integer.Type.Integer,
    ||                     integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)],
    ||                   containers-0.5.6.2:Data.Set.Base.Set
    ||                     integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)
    || In the second argument of ‘containers-0.5.6.2:Data.Map.Base.map’, namely
    ||   ‘zippedMap’
    || In the second argument of ‘(GHC.Base.$)’, namely
    ||   ‘containers-0.5.6.2:Data.Map.Base.map
    ...

which clutters the screen and it&#39;s very hard for me to find out where went wrong. As comparison, this is the error message for the same file using `ghci`:

    test.hs:71:13:
        Couldn&#39;t match type ‘T.Text’ with ‘[Char]’
        Expected type: M.Map [Char] ([(Integer, Integer)], S.Set Integer)
          Actual type: M.Map T.Text ([(Integer, Integer)], S.Set Integer)
        In the second argument of ‘M.map’, namely ‘zippedMap’
        In the second argument of ‘($)’, namely
          ‘M.map
    ...

which is much cleaner. Is there a way to make `ghc-mod` use short names for the types?

Does GHC-mod have to use full names for types?

I'm trying to use the <code>ghc-mod</code> vim plugin to do type/syntax checking etc. However, I found that <code>ghc-mod</code> always uses full paths of types in the error messages, for example:
<pre><code class="hljs language-vbnet">test.hs|71 col 13 error| Couldn't match type ‘Data.Text.Internal.Text’ 
|| with ‘[GHC.Types.Char]’
|| Expected type: containers-0.5.6.2:Data.Map.Base.Map
|| [GHC.Types.Char]
|| ([(integer-gmp-1.0.0.0:GHC.Integer.Type.Integer,
|| integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)],
|| containers-0.5.6.2:Data.Set.Base.Set
|| integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)
|| Actual type: containers-0.5.6.2:Data.Map.Base.Map
|| Data.Text.Internal.Text
|| ([(integer-gmp-1.0.0.0:GHC.Integer.Type.Integer,
|| integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)],
|| containers-0.5.6.2:Data.Set.Base.Set
|| integer-gmp-1.0.0.0:GHC.Integer.Type.Integer)
|| In the second argument of ‘containers-0.5.6.2:Data.Map.Base.map’, namely
|| ‘zippedMap’
|| In the second argument of ‘(GHC.Base.$)’, namely
|| ‘containers-0.5.6.2:Data.Map.Base.map
...
</code></pre>
which clutters the screen and it's very hard for me to find out where went wrong. As comparison, this is the error message for the same file using <code>ghci</code>:
<pre><code class="hljs language-vbnet">test.hs:71:13:
 Couldn't match type ‘T.Text’ with ‘[Char]’
 Expected type: M.Map [Char] ([(Integer, Integer)], S.Set Integer)
 Actual type: M.Map T.Text ([(Integer, Integer)], S.Set Integer)
 In the second argument of ‘M.map’, namely ‘zippedMap’
 In the second argument of ‘($)’, namely
 ‘M.map
...
</code></pre>
which is much cleaner. Is there a way to make <code>ghc-mod</code> use short names for the types?

Haskell (with the `GHC` compiler) is a [lot faster than you&#39;d expect][1]. Used correctly, it can get close-ish to low-level languages. (A favorite thing for Haskellers to do is to try and get within 5% of C (or even beat it, but that means you are using an inefficient C program, since GHC compiles Haskell to C).) My question is, why?

Haskell is declarative and based on lambda calculus. Machine architectures are clearly imperative, being based on turing machines, roughly. Indeed, Haskell doesn&#39;t even have a specific evaluation order. Also, instead of dealing with machine data types, you make algebraic data types all the time.

Weirdest of all though is higher order functions. You would think that creating functions on the fly, and throwing them around, would make a program slower. [But using higher order functions actually makes Haskell faster.][2] Indeed, it seems that, to optimize Haskell code, you need to make it more elegant and abstract instead of more machine-like. None of Haskell&#39;s more advanced features seem to even *affect* its performance, if they don&#39;t improve it.

Sorry if this is sounding ranty, but here is my question: **Why is Haskell (compiled with GHC) so fast, considering its abstract nature and differences from physical machines?**

Note: The reason I say C and other imperative languages are somewhat similar to Turing Machines (but not to the extent that Haskell is similar to Lambda Calculus) is that in an imperative language, you have a finite number of states (a.k.a. line number), along with a Tape (the ram), such that the state and the current tape determine what to do to the tape. See the Wikipedia entry, [Turing machine equivalents][0], for the transition from Turing Machines to computers.

  [0]: https://en.wikipedia.org/wiki/Turing_machine_equivalents
  [1]: https://wiki.haskell.org/Why_Haskell_matters#The_speed_of_Haskell
  [2]: https://hbtvl.wordpress.com/2015/12/14/efficient-parsing-of-large-text-files-part-4-and-conclusion/

Why is Haskell (GHC) so darn fast?

As the title of the question indicates, I want to know what is Levity polymorphism and what is its motivation ? I know [this page](https://ghc.haskell.org/trac/ghc/wiki/NoSubKinds) has some details in it, but most of the explanations there go over the top of my head. :)

While [this page](http://ezyang.tumblr.com/post/127984263867/richard-eisenberg-levity-polymorphism-hiw) is a little friendlier, I&#39;m still not able to understand the motivation behind it.

What is Levity polymorphism

We are developing a program which receives and forwards &quot;messages&quot;, while keeping a temporary history of those messages, so that it can tell you the message history if requested. Messages are identified numerically, are typically around 1 kilobyte in size, and we need to keep hundreds of thousands of these messages.

We wish to optimize this program for latency: the time between sending and receiving a message must be below 10 milliseconds.

The program is written in Haskell and compiled with GHC. However, we have found that garbage collection pauses are far too long for our latency requirements: over 100 milliseconds in our real-world program.

The following program is a simplified version of our application. It uses a `Data.Map.Strict` to store messages. Messages are `ByteString`s identified by an `Int`. 1,000,000 messages are inserted in increasing numeric order, and the oldest messages are continually removed to keep the history at a maximum of 200,000 messages.

    module Main (main) where

    import qualified Control.Exception as Exception
    import qualified Control.Monad as Monad
    import qualified Data.ByteString as ByteString
    import qualified Data.Map.Strict as Map

    data Msg = Msg !Int !ByteString.ByteString

    type Chan = Map.Map Int ByteString.ByteString

    message :: Int -&gt; Msg
    message n = Msg n (ByteString.replicate 1024 (fromIntegral n))

    pushMsg :: Chan -&gt; Msg -&gt; IO Chan
    pushMsg chan (Msg msgId msgContent) =
      Exception.evaluate $
        let
          inserted = Map.insert msgId msgContent chan
        in
          if 200000 &lt; Map.size inserted
          then Map.deleteMin inserted
          else inserted

    main :: IO ()
    main = Monad.foldM_ pushMsg Map.empty (map message [1..1000000])

We compiled and ran this program using:

    $ ghc --version
    The Glorious Glasgow Haskell Compilation System, version 7.10.3
    $ ghc -O2 -optc-O3 Main.hs
    $ ./Main +RTS -s
       3,116,460,096 bytes allocated in the heap
         385,101,600 bytes copied during GC
         235,234,800 bytes maximum residency (14 sample(s))
         124,137,808 bytes maximum slop
                 600 MB total memory in use (0 MB lost due to fragmentation)

                                         Tot time (elapsed)  Avg pause  Max pause
      Gen  0      6558 colls,     0 par    0.238s   0.280s     0.0000s    0.0012s
      Gen  1        14 colls,     0 par    0.179s   0.250s     0.0179s    0.0515s

      INIT    time    0.000s  (  0.000s elapsed)
      MUT     time    0.652s  (  0.745s elapsed)
      GC      time    0.417s  (  0.530s elapsed)
      EXIT    time    0.010s  (  0.052s elapsed)
      Total   time    1.079s  (  1.326s elapsed)

      %GC     time      38.6%  (40.0% elapsed)

      Alloc rate    4,780,213,353 bytes per MUT second

      Productivity  61.4% of total user, 49.9% of total elapsed

The important metric here is the &quot;max pause&quot; of 0.0515s, or 51 milliseconds. We wish to reduce this by at least an order of magnitude.

Experimentation shows that the length of a GC pause is determined by the number of messages in the history. The relationship is roughly linear, or perhaps super-linear. The following table shows this relationship. ([You can see our benchmarking tests here](https://github.com/jameshfisher/ghc_gc_benchmarks), and [some charts here](https://docs.google.com/spreadsheets/d/1mDXrk8bqPb_nsR__pzHtSxwO8a_6bPVL8hd3Y9lCIm0/edit?usp=sharing).)

    msgs history length  max GC pause (ms)
    ===================  =================
    12500                                3
    25000                                6
    50000                               13
    100000                              30
    200000                              56
    400000                             104
    800000                             199
    1600000                            487
    3200000                           1957
    6400000                           5378

We have experimented with several other variables to find whether they can reduce this latency, none of which make a big difference. Among these unimportant variables are: optimization (`-O`, `-O2`); RTS GC options (`-G`, `-H`, `-A`, `-c`), number of cores (`-N`), different data structures (`Data.Sequence`), the size of messages, and the amount of generated short-lived garbage. The overwhelming determining factor is the number of messages in the history.

Our working theory is that the pauses are linear in the number of messages because each GC cycle has to walk over all the working accessible memory and copy it, which are clearly linear operations.

Questions:

* Is this linear-time theory correct? Can the length of GC pauses be expressed in this simple way, or is the reality more complex?
* If GC pause is linear in the working memory, is there any way to reduce the constant factors involved?
* Are there any options for incremental GC, or anything like it? We can only see research papers. We are very willing to trade throughput for lower latency.
* Are there any ways to &quot;partition&quot; memory for smaller, GC cycles, other than splitting into multiple processes?

Reducing garbage-collection pause time in a Haskell program

While reading a piece of Haskell code I came upon this: `&lt;$&gt;`. What does it mean in Haskell? After some google searches I remain in the dark.

What does &lt;$&gt; mean in Haskell?

Haskell version(1.03s):

&lt;!-- language: haskell --&gt;

    module Main where
      import qualified Data.Text as T
      import qualified Data.Text.IO as TIO
      import Control.Monad
      import Control.Applicative ((&lt;$&gt;))
      import Data.Vector.Unboxed (Vector,(!))
      import qualified Data.Vector.Unboxed as V
    
      solve :: Vector Int -&gt; Int
      solve ar =
        V.foldl&#39; go 0 ar&#39; where
          ar&#39; = V.zip ar (V.postscanr&#39; max 0 ar)
          go sr (p,m) = sr + m - p
    
      main = do
        t &lt;- fmap (read . T.unpack) TIO.getLine -- With Data.Text, the example finishes 15% faster.
        T.unlines . map (T.pack . show . solve . V.fromList . map (read . T.unpack) . T.words)
          &lt;$&gt; replicateM t (TIO.getLine &gt;&gt; TIO.getLine) &gt;&gt;= TIO.putStr

F# version(0.17s):

&lt;!-- language: f# --&gt;

    open System
    
    let solve (ar : uint64[]) =
        let ar&#39; = 
            let t = Array.scanBack max ar 0UL |&gt; fun x -&gt; Array.take (x.Length-1) x
            Array.zip ar t
        
        let go sr (p,m) = sr + m - p
        Array.fold go 0UL ar&#39;
    
    let getIntLine() =
        Console.In.ReadLine().Split [|&#39; &#39;|]
        |&gt; Array.choose (fun x -&gt; if x &lt;&gt; &quot;&quot; then uint64 x |&gt; Some else None)    
    
    let getInt() = getIntLine().[0]
    
    let t = getInt()
    for i=1 to int t do
        getInt() |&gt; ignore
        let ar = getIntLine()
        printfn &quot;%i&quot; (solve ar)

The above two programs are the solutions for the [Stock Maximize problem](https://www.hackerrank.com/challenges/stockmax/) and times are for the first test case of the `Run Code` button.

For some reason the F# version is roughly 6x faster, but I am pretty sure that if I replaced the slow library functions with imperative loops that I could speed it up by at least 3 times and more likely 10x.

Could the Haskell version be similarly improved?

I am doing the above for learning purposes and in general I am finding it difficult to figure out how to write efficient Haskell code.

Content Type	Original Author	Original Content on Stackoverflow
Question	xzhu	View Question on Stackoverflow
Solution 1 - Haskell	Kronos	View Answer on Stackoverflow
Solution 2 - Haskell	sergv	View Answer on Stackoverflow

Does GHC-mod have to use full names for types?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

A better way to check if a path exists or not in PowerShell

Why is inequality tested as (!(a==b)) in a lot of C++ standard library code?

Attributions