Shipping an executable with `Language.Haskell.Interpreter` seems to go perfect with the way you have shown. You have to set your `PATH` to the script you want to execute.

And as of side note, as mentioned by @bennofs in comments, Statically linking the GHC API doesn&#39;t work with the new dynamic linker introduced in GHC 7.8, (interactive code execution now requires dynamic libraries).

In the process of answering [another question](https://stackoverflow.com/q/28266382/3959454) I stumbled upon slightly different wordings for `std::vector::erase()` and `std::deque::erase()`. 

This is what C++14 says about `std::deque::erase` (`[deque.modifiers]/4-6`, emphasis mine):

&gt; *Effects:* ...

&gt; *Complexity:* The number of calls to the destructor is the same as the number of elements erased, but
The number of calls to the **assignment operator** is no more than the lesser of the number of elements
Before the erased elements and the number of elements after the erased elements.

&gt; *Throws:* Nothing unless an exception is thrown by the copy constructor, move constructor, assignment operator, or move assignment operator of `T`.


And here is what it says about `std::vector::erase` (`[vector.modifiers]/3-5`):

&gt; *Effects:* ...

&gt; *Complexity:* The destructor of `T` is called the number of times equal to the number of the elements erased, but the **move assignment operator** of `T` is called the number of times equal to the number of elements in the vector after the erased elements.

&gt; *Throws:* Nothing unless an exception is thrown by the copy constructor, move constructor, assignment operator, or move assignment operator of `T`.

As you can see, the exception specifications for both of them are the same, but for `std::vector` it&#39;s explicitly mentioned that move assignment operator is called.

There&#39;s also requirement for `T` to be `MoveAssignable` for `erase()` to work with both `std::vector` and `std::deque` (Table 100), but this doesn&#39;t imply the presence of the move assignment operator: one can define a copy assignment operator, and not define move assignment operator, and this class will be `MoveAssignable`.

Just in case, I checked with GCC and Clang, and indeed `std::vector::erase()` calls copy assignment operator if there&#39;s no move assignment operator, and `std::deque::erase()` does the same ([DEMO](http://coliru.stacked-crooked.com/a/c9377a2ee408fa16)).

So the question is: did I miss something, or this is an (editorial) issue in the standard?

**Update:**
I&#39;ve submitted an [LWG issue #2477](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2477).

Copy/move assignment in std::vector::erase() and std::deque::erase()

I am learning Docker and I have doubts about when and where to use `ADD` and `VOLUME`. Here is what I think both of these do:

ADD
---
Copy files to the image at build time. The image has all the files so you can deploy very easily.  On the other hand, needing to build every time doesn&#39;t look like a good idea in development because building requires the developer to run a command to rebuild the container; additionally, building the container can be time-consuming.

VOLUME
---
I understand that using `docker run -v` you can mount a host folder inside your container, this way you can easily modify files and watch the app in your container react to the changes. It looks great in development, but I am not sure how to deploy my files this way.

Docker ADD vs VOLUME

I was hoping to embed a Haskell interpreter using `hint` so that I could write plugins in Haskell to use with my program. I don&#39;t want to have to ship the entire Haskell platform for my executables. 

Normally, Haskell executables are pretty self-contained. For example, erasing the `PATH` does not cause a problem:

    $ PATH=. Hello
    Hello world

However, a simple test program using `runInterpreter` bombs if I erase the `PATH`:

    $ PATH=. TryHint
    GhcException &quot;panic! (the &#39;impossible&#39; happened)\n  (GHC version 7.8.3 for x86_64-apple-darwin):\n\tDynamic linker not initialised\n\nPlease report this as a GHC bug:  http://www.haskell.org/ghc/reportabug\n&quot;

**What libraries or executables have to be available in the environment for it to work?**

`otool` doesn&#39;t give much guidance:

    otool -L TryHint
    TryHint:
    	/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
    	/usr/lib/libiconv.2.dylib (compatibility version 7.0.0, current version 7.0.0)
    	/usr/local/lib/libgmp.10.dylib (compatibility version 13.0.0, current version 13.0.0)

The test code for `TryHint` does not do much:

    import Control.Monad
    import Language.Haskell.Interpreter

    main = do
      f &lt;- runInterpreter $ loadModules [&quot;Test&quot;] &gt;&gt; setTopLevelModules [&quot;Test&quot;] &gt;&gt; interpret &quot;f&quot; (as :: Int -&gt; Int)
      case f of
        Left e -&gt; print e
        Right r -&gt; mapM_ (print . r) [1..10]

It just binds `f` to a function in `Test.hs` to be interpreted at run-time. `Test.hs` looks like this:

    module Test where
    f :: Int -&gt; Int
    f x = x + 1


How to ship an executable with Language.Haskell.Interpreter?

I was hoping to embed a Haskell interpreter using <code>hint</code> so that I could write plugins in Haskell to use with my program. I don't want to have to ship the entire Haskell platform for my executables.
Normally, Haskell executables are pretty self-contained. For example, erasing the <code>PATH</code> does not cause a problem:
<pre><code class="hljs language-ini">$ PATH=. Hello
Hello world
</code></pre>
However, a simple test program using <code>runInterpreter</code> bombs if I erase the <code>PATH</code>:
<pre><code class="hljs language-swift">$ PATH=. TryHint
GhcException "panic! (the 'impossible' happened)\n (GHC version 7.8.3 for x86_64-apple-darwin):\n\tDynamic linker not initialised\n\nPlease report this as a GHC bug: http://www.haskell.org/ghc/reportabug\n"
</code></pre>
What libraries or executables have to be available in the environment for it to work?
<code>otool</code> doesn't give much guidance:
<pre><code class="hljs language-sql">otool -L TryHint
TryHint:
	/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
	/usr/lib/libiconv.2.dylib (compatibility version 7.0.0, current version 7.0.0)
	/usr/local/lib/libgmp.10.dylib (compatibility version 13.0.0, current version 13.0.0)
</code></pre>
The test code for <code>TryHint</code> does not do much:
<pre><code class="hljs language-arduino">import Control.Monad
import Language.Haskell.Interpreter

main = do
 f &#x3C;- runInterpreter $ loadModules ["Test"] >> setTopLevelModules ["Test"] >> interpret "f" (as :: Int -> Int)
 case f of
 Left e -> print e
 Right r -> mapM_ (print . r) [1..10]
</code></pre>
It just binds <code>f</code> to a function in <code>Test.hs</code> to be interpreted at run-time. <code>Test.hs</code> looks like this:
<pre><code class="hljs language-sql">module Test where
f :: Int -> Int
f x = x + 1
</code></pre>

Working code:

    import System
    main = do
         [file1, file2] &lt;- getArgs
         --copy file contents
         str &lt;- readFile file1
         writeFile file2 str
Crashing code:

    import System
    main = do
           [file1, file2] = getArgs
           str = readFile file1
           writeFile file2 str
When I tried, it threw an error as:

&gt; a.hs:6:18: parse error on input &#39;=&#39;

So, how different is `&lt;-` from `=`?

Equal (=) Vs left arrow (&lt;-) symbols in haskell

What is [indexed monad](https://hackage.haskell.org/package/indexed-0.1/docs/Control-Monad-Indexed.html) and the motivation for this monad?

I have read that it helps to keep track of the side effects. But the type signature and documentation doesn&#39;t lead me to anywhere.

What would be an example of how it can help to keep track of side effects (or any other valid example)?


What is indexed monad?

This piece of Haskell code runs *much* slower with `-O`, but `-O` should be [non-dangerous](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/options-optimise.html#optimise-pkgs). Can anyone tell me what happened? If it matters, it is an attempt to solve [this problem](http://tioj.ck.tp.edu.tw/problems/1827), and it uses binary search and persistent segment tree:

    import Control.Monad
    import Data.Array
    
    data Node =
    	  Leaf   Int           -- value
    	| Branch Int Node Node -- sum, left child, right child
    type NodeArray = Array Int Node
    
    -- create an empty node with range [l, r)
    create :: Int -&gt; Int -&gt; Node
    create l r
    	| l + 1 == r = Leaf 0
    	| otherwise  = Branch 0 (create l m) (create m r)
    	where m = (l + r) `div` 2
    
    -- Get the sum in range [0, r). The range of the node is [nl, nr)
    sumof :: Node -&gt; Int -&gt; Int -&gt; Int -&gt; Int
    sumof (Leaf val) r nl nr
    	| nr &lt;= r   = val
    	| otherwise = 0
    sumof (Branch sum lc rc) r nl nr
    	| nr &lt;= r   = sum
    	| r  &gt; nl   = (sumof lc r nl m) + (sumof rc r m nr)
    	| otherwise = 0
    	where m = (nl + nr) `div` 2
    
    -- Increase the value at x by 1. The range of the node is [nl, nr)
    increase :: Node -&gt; Int -&gt; Int -&gt; Int -&gt; Node
    increase (Leaf val) x nl nr = Leaf (val + 1)
    increase (Branch sum lc rc) x nl nr
    	| x &lt; m     = Branch (sum + 1) (increase lc x nl m) rc
    	| otherwise = Branch (sum + 1) lc (increase rc x m nr)
    	where m = (nl + nr) `div` 2
    
    -- signature said it all
    tonodes :: Int -&gt; [Int] -&gt; [Node]
    tonodes n = reverse . tonodes&#39; . reverse
    	where
    		tonodes&#39; :: [Int] -&gt; [Node]
    		tonodes&#39; (h:t) = increase h&#39; h 0 n : s&#39; where s&#39;@(h&#39;:_) = tonodes&#39; t
    		tonodes&#39; _ = [create 0 n]
    
    -- find the minimum m in [l, r] such that (predicate m) is True
    binarysearch :: (Int -&gt; Bool) -&gt; Int -&gt; Int -&gt; Int
    binarysearch predicate l r
        | l == r      = r
        | predicate m = binarysearch predicate l m
        | otherwise   = binarysearch predicate (m+1) r
        where m = (l + r) `div` 2
    
    -- main, literally
    main :: IO ()
    main = do
    	[n, m] &lt;- fmap (map read . words) getLine
    	nodes &lt;- fmap (listArray (0, n) . tonodes n . map (subtract 1) . map read . words) getLine
    	replicateM_ m $ query n nodes
    	where
    		query :: Int -&gt; NodeArray -&gt; IO ()
    		query n nodes = do
    			[p, k] &lt;- fmap (map read . words) getLine
    			print $ binarysearch (ok nodes n p k) 0 n
    			where
    				ok :: NodeArray -&gt; Int -&gt; Int -&gt; Int -&gt; Int -&gt; Bool
    				ok nodes n p k s = (sumof (nodes ! min (p + s + 1) n) s 0 n) - (sumof (nodes ! max (p - s) 0) s 0 n) &gt;= k

(This is exactly the same code with [code review](https://codereview.stackexchange.com/q/85557/24928) but this question addresses another problem.)

This is my input generator in C++:

&lt;!-- language: lang-cpp --&gt;

    #include &lt;cstdio&gt;
    #include &lt;cstdlib&gt;
    using namespace std;
    int main (int argc, char * argv[]) {
        srand(1827);
        int n = 100000;
        if(argc &gt; 1)
            sscanf(argv[1], &quot;%d&quot;, &amp;n);
        printf(&quot;%d %d\n&quot;, n, n);
        for(int i = 0; i &lt; n; i++)
            printf(&quot;%d%c&quot;, rand() % n + 1, i == n - 1 ? &#39;\n&#39; : &#39; &#39;);
        for(int i = 0; i &lt; n; i++) {
            int p = rand() % n;
            int k = rand() % n + 1;
            printf(&quot;%d %d\n&quot;, p, k);
        }
    }

In case you don&#39;t have a C++ compiler available, [this is the result of `./gen.exe 1000`](http://pastebin.com/rDH7zCX9).

This is the execution result on my computer:

&lt;!-- language: none --&gt;

    $ ghc --version
    The Glorious Glasgow Haskell Compilation System, version 7.8.3
    $ ghc -fforce-recomp 1827.hs
    [1 of 1] Compiling Main             ( 1827.hs, 1827.o )
    Linking 1827.exe ...
    $ time ./gen.exe 1000 | ./1827.exe &gt; /dev/null
    real    0m0.088s
    user    0m0.015s
    sys     0m0.015s
    $ ghc -fforce-recomp -O 1827.hs
    [1 of 1] Compiling Main             ( 1827.hs, 1827.o )
    Linking 1827.exe ...
    $ time ./gen.exe 1000 | ./1827.exe &gt; /dev/null
    real    0m2.969s
    user    0m0.000s
    sys     0m0.045s

And this is the heap profile summary:

&lt;!-- language: none --&gt;

    $ ghc -fforce-recomp -rtsopts ./1827.hs
    [1 of 1] Compiling Main             ( 1827.hs, 1827.o )
    Linking 1827.exe ...
    $ ./gen.exe 1000 | ./1827.exe +RTS -s &gt; /dev/null
          70,207,096 bytes allocated in the heap
           2,112,416 bytes copied during GC
             613,368 bytes maximum residency (3 sample(s))
              28,816 bytes maximum slop
                   3 MB total memory in use (0 MB lost due to fragmentation)
                                        Tot time (elapsed)  Avg pause  Max pause
      Gen  0       132 colls,     0 par    0.00s    0.00s     0.0000s    0.0004s
      Gen  1         3 colls,     0 par    0.00s    0.00s     0.0006s    0.0010s
      INIT    time    0.00s  (  0.00s elapsed)
      MUT     time    0.03s  (  0.03s elapsed)
      GC      time    0.00s  (  0.01s elapsed)
      EXIT    time    0.00s  (  0.00s elapsed)
      Total   time    0.03s  (  0.04s elapsed)
      %GC     time       0.0%  (14.7% elapsed)
      Alloc rate    2,250,213,011 bytes per MUT second
      Productivity 100.0% of total user, 83.1% of total elapsed
    $ ghc -fforce-recomp -O -rtsopts ./1827.hs
    [1 of 1] Compiling Main             ( 1827.hs, 1827.o )
    Linking 1827.exe ...
    $ ./gen.exe 1000 | ./1827.exe +RTS -s &gt; /dev/null
       6,009,233,608 bytes allocated in the heap
         622,682,200 bytes copied during GC
             443,240 bytes maximum residency (505 sample(s))
              48,256 bytes maximum slop
                   3 MB total memory in use (0 MB lost due to fragmentation)
                                        Tot time (elapsed)  Avg pause  Max pause
      Gen  0     10945 colls,     0 par    0.72s    0.63s     0.0001s    0.0004s
      Gen  1       505 colls,     0 par    0.16s    0.13s     0.0003s    0.0005s
      INIT    time    0.00s  (  0.00s elapsed)
      MUT     time    2.00s  (  2.13s elapsed)
      GC      time    0.87s  (  0.76s elapsed)
      EXIT    time    0.00s  (  0.00s elapsed)
      Total   time    2.89s  (  2.90s elapsed)
      %GC     time      30.3%  (26.4% elapsed)
      Alloc rate    3,009,412,603 bytes per MUT second
      Productivity  69.7% of total user, 69.4% of total elapsed




Why does this Haskell code run slower with -O?

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 am trying to write `setup.py` for my package. My package needs to specify a dependency on another Git repository.

This is what I have so far:

    from setuptools import setup, find_packages

    setup(
        name=&#39;abc&#39;,
        packages=find_packages(),
        url=&#39;https://github.abc.com/abc/myabc&#39;,
        description=&#39;This is a description for abc&#39;,
        long_description=open(&#39;README.md&#39;).read(),
        install_requires=[
            &quot;requests==2.7.0&quot;,
            &quot;SomePrivateLib&gt;=0.1.0&quot;,
            ],
        dependency_links = [
         &quot;git+git://github.abc.com/abc/SomePrivateLib.git#egg=SomePrivateLib&quot;,
        ],
        include_package_data=True,
    )

When I run:

    pip install -e https://github.abc.com/abc/myabc.git#egg=analyse

I get

&gt; Could not find a version that satisfies the requirement
&gt; SomePrivateLib&gt;=0.1.0 (from analyse) (from versions: ) No matching
&gt; distribution found for SomePrivateLib&gt;=0.1.0 (from analyse)

What am I doing wrong?





How to write setup.py to include a Git repository as a dependency

### Background
I was about to try Python package downloaded from GitHub, and realized that it did not have a `setup.py`, so I could not install it with
```
pip install -e &lt;folder&gt;
```
Instead, the package had a **`pyproject.toml`** file which seems to have very similar entries as the `setup.py` usually has.

### What I found
Googling lead me into [PEP-518] and it gives some critique to `setup.py` in [Rationale] section. However, it does not clearly tell that usage of `setup.py` should be avoided, or that `pyproject.toml` would as such completely replace `setup.py`.

### Questions
Is the `pyproject.toml` something that is used to replace `setup.py`? Or should a package come with both, a `pyproject.toml` and a `setup.py`?  
How would one install a project with `pyproject.toml` in an editable state?

[PEP-518]: https://www.python.org/dev/peps/pep-0518/
[Rationale]: https://www.python.org/dev/peps/pep-0518/#rationale

Content Type	Original Author	Original Content on Stackoverflow
Question	Michael Fox	View Question on Stackoverflow
Solution 1 - Haskell	Himanshu Mishra	View Answer on Stackoverflow

How to ship an executable with Language.Haskell.Interpreter?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Docker ADD vs VOLUME

Copy/move assignment in std::vector::erase() and std::deque::erase()

Attributions