    stack install hakyll

``stack`` offers a curated set of packages that won&#39;t blow your machine up. If you want to check what packages are available, or exactly what version is supported, or on what version of ``GHC`` you can get it, check out https://www.stackage.org/.

For example, you can get ``hakyll 4.6.9.0`` right now for both ``GHC 7.8.4`` and ``GHC 7.10.1``. Pretty neat. - [source](https://www.stackage.org/lts-2.20/package/hakyll-4.6.9.0)

**EDIT**: I forgot to mention, Yuan Wang&#39;s method works for getting the version of ``hakyll`` that is not curated into ``stackage``. It&#39;s up to you what version you need.

add hakyll in stack.yaml generated by &lt;code&gt;stack init&lt;/code&gt; or &lt;code&gt;stack new&lt;/code&gt;

yaml file should look like:

    flags: {}
    packages:
      - &#39;.&#39;
    extra-deps:
      - hakyll-4.7.1.0
    resolver: lts-2.15


after that, run `stack solver` installs it

https://github.com/commercialhaskell/stack/wiki/stack.yaml

[This documentation][1] worked for me 

On `package.yaml` add the library under `dependencies`, for example:

    dependencies:
    - base &gt;= 4.7 &amp;&amp; &lt; 5
    - hakyll # added here

  [1]: https://docs.haskellstack.org/en/stable/GUIDE/#adding-dependencies


I&#39;m using Laravel (a PHP framework) to write a service for mobile and have the data returned in `JSON` format. In the data result there are some fields encoded in `UTF-8`. 

The following statement

    return JsonResponse::create($data); 

returns the error below

    InvalidArgumentException
    HELP
    Malformed UTF-8 characters, possibly incorrectly encoded

    Open: /var/www/html/vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/JsonResponse.php
            } catch (\Exception $exception) {
                restore_error_handler();
     
                throw $exception;
            }
     
            if (JSON_ERROR_NONE !== json_last_error()) {
                throw new \InvalidArgumentException($this-&gt;transformJsonError());
            }


I&#39;ve changed:

    return JsonResponse::create($data);

to

    return JsonResponse::create($data, 200, array(&#39;Content-Type&#39;=&gt;&#39;application/json; charset=utf-8&#39; ));

but it still isn&#39;t working.

How can I fix it?
 




&#39;Malformed UTF-8 characters, possibly incorrectly encoded&#39; in Laravel

This was an interview question:

    public class Demo {

        public static void main(String[] args) {
            System.out.println(foo());
        }

        static String foo() {
            try {
                return &quot;try ...&quot;;
            } catch (Exception e) {
                return &quot;catch ...&quot;;
            } finally {
                return &quot;finally ...&quot;; //got as result
            }
        }
    }

My question is why there are no compile time errors. When I have the return statement in my `finally` block, it is bound to return from `finally` instead of `try` and `catch` block. I tried to compile this code with `-Xlint` option, it gives a warning as.

    warning: [finally] finally clause cannot complete normally

Multiple return statements without compiler error

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?

<p>Using cabal, I could install hakyll with the command:</p>
<pre><code class="hljs">cabal install hakyll
</code></pre>
<p>How can I do the same thing using stack?</p>


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 am trying to parallelize a ray-tracer. This means I have a very long list of small computations. The vanilla program runs on a specific scene in 67.98 seconds and 13 MB of total memory use and 99.2% productivity.

In my first attempt I used the parallel strategy `parBuffer` with a buffer size of 50. I chose `parBuffer` because it walks through the list only as fast as sparks are consumed, and does not force the spine of the list like `parList`, which would use a lot of memory since the list is very long. With `-N2`, it ran in a time of 100.46 seconds and 14 MB of total memory use and 97.8% productivity. The spark information is: `SPARKS: 480000 (476469 converted, 0 overflowed, 0 dud, 161 GC&#39;d, 3370 fizzled)`

The large proportion of fizzled sparks indicates that the granularity of sparks was too small, so next I tried using the strategy `parListChunk`, which splits the list into chunks and creates a spark for each chunk. I got the best results with a chunk size of `0.25 * imageWidth`. The program ran in 93.43 seconds and 236 MB of total memory use and 97.3% productivity. The spark information is: `  SPARKS: 2400 (2400 converted, 0 overflowed, 0 dud, 0 GC&#39;d, 0 fizzled)`. I believe the much greater memory use is because `parListChunk` forces the spine of the list.

Then I tried to write my own strategy that lazily divided the list into chunks and then passed the chunks to `parBuffer` and concatenated the results.

     concat $ withStrategy (parBuffer 40 rdeepseq) (chunksOf 100 (map colorPixel pixels))

This ran in 95.99 seconds and 22MB of total memory use and 98.8% productivity. This was succesful in the sense that all the sparks are being converted and the memory usage is much lower, however the speed is not improved. Here is an image of part of the eventlog profile.[![Event log profile][1]][1]

     
  [1]: http://i.stack.imgur.com/JoaHO.png

As you can see the threads are being stopped due to heap overflows. I tried adding `+RTS -M1G` which increases the default heap size all the way up to 1Gb. The results did not change. I read that Haskell main thread will use memory from the heap if its stack overflows, so I also tried increasing the default stack size too with `+RTS -M1G -K1G` but this also had no impact.

Is there anything else I can try? I can post more detailed profiling info for memory usage or eventlog if needed, I did not include it all because it is a lot of information and I did not think all of it was necessary to include.

EDIT: I was reading about the [Haskell RTS multicore support](http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/multicore-ghc.pdf), and it talks about there being a HEC (Haskell Execution Context) for each core. Each HEC contains, among other things, an Allocation Area (which is a part of a single shared heap). Whenever any HEC&#39;s Allocation Area is exhausted, a garbage collection must be performed. The appears to be a [RTS option](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/runtime-control.html) to control it, -A. I tried -A32M but saw no difference.

EDIT2:
[Here is a link to a github repo dedicated to this question](https://github.com/jrraymond/ray-tracer-so). I have included the profiling results in the profiling folder.

EDIT3: Here is the relevant bit of code:

    render :: [([(Float,Float)],[(Float,Float)])] -&gt; World -&gt; [Color]
    render grids world = cs where 
      ps = [ (i,j) | j &lt;- reverse [0..wImgHt world - 1] , i &lt;- [0..wImgWd world - 1] ]
      cs = map (colorPixel world) (zip ps grids)
      --cs = withStrategy (parListChunk (round (wImgWd world)) rdeepseq) (map (colorPixel world) (zip ps grids))
      --cs = withStrategy (parBuffer 16 rdeepseq) (map (colorPixel world) (zip ps grids))
      --cs = concat $ withStrategy (parBuffer 40 rdeepseq) (chunksOf 100 (map (colorPixel world) (zip ps grids)))

The grids are random floats that are precomputed and used by colorPixel.The type of `colorPixel` is:

     colorPixel :: World -&gt; ((Float,Float),([(Float,Float)],[(Float,Float)])) -&gt; Color


Haskell threads heap overflow despite only 22Mb total memory usage?

I am trying to define a new monad and I am getting a strange error

**newmonad.hs**
&lt;pre&gt;
newtype Wrapped a = Wrap {unwrap :: a}
instance Monad Wrapped where
  (&gt;&gt;=) (Wrap x) f =  f x
  return x = Wrap x

main = do
  putStrLn &quot;yay&quot;
&lt;/pre&gt;

&lt;pre&gt;
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.10.1

$ ghc newmonad.hs 
[1 of 1] Compiling Main             ( newmonad.hs, newmonad.o )

newmonad.hs:2:10:
    No instance for (Applicative Wrapped)
      arising from the superclasses of an instance declaration
    In the instance declaration for ‚&#196;&#242;Monad Wrapped‚&#196;&#244;
&lt;/pre&gt;

Why do I need to define an instance of `Applicative`?

Defining a new monad in haskell raises no instance for Applicative

Church numbers are an encoding of natural numbers as functions.

    (\ f x → (f x))             -- church number 1
    (\ f x → (f (f (f x))))     -- church number 3
    (\ f x → (f (f (f (f x))))) -- church number 4

Neatly, you can exponentiate 2 church numbers by just applying them. That is, if you apply 4 to 2, you get the church number `16`, or `2^4`. Obviously,  that is utterly unpractical. Church numbers need a linear amount of memory and are really, really slow. Computing something like `10^10` - which GHCI quickly answers correctly - would take ages and couldn&#39;t fit the memory on your computer anyway. 

I&#39;ve been experimenting with optimal λ evaluators lately. On my tests, I accidentally typed the following on my optimal λ-calculator:

    10 ^ 10 % 13

It was supposed to be multiplication, not exponentiation. Before I could move my fingers to abort the forever-running program in despair, it answered my request:
 
    3
    { iterations: 11523, applications: 5748, used_memory: 27729 }

    real	0m0.104s
    user	0m0.086s
    sys	    0m0.019s

With my &quot;bug alert&quot; flashing, I went to Google and verified, `10^10%13 == 3` indeed. **But the λ-calculator wasn&#39;t supposed to find that result, it can barely store 10^10.** I started stressing it, for science. It instantly answered me `20^20%13 == 3`, `50^50%13 == 4`, `60^60%3 == 0`. I had to use [external tools](https://www.mtholyoke.edu/courses/quenell/s2003/ma139/js/powermod.html) to verify those results, since &lt;s&gt;Haskell itself wasn&#39;t able to compute it (due to integer overflow)&lt;/s&gt; (it is if you use Integers not Ints, of course!). Pushing it to its limits, this was the answer to `200^200%31`:

    5
    { iterations: 10351327, applications: 5175644, used_memory: 23754870 }

    real	0m4.025s
    user	0m3.686s
    sys	0m0.341s

If we had one copy of the universe for each atom on the universe, and we had a computer for each atom we had in total, we couldn&#39;t store the church number `200^200`. This prompted me to question if my mac was really that powerful. Maybe the optimal evaluator was able to skip the unnecessary branches and arrive right at the answer in the same fashion Haskell does with lazy evaluation. To test this, I compiled the λ program to Haskell:

    data Term = F !(Term -&gt; Term) | N !Double
    instance Show Term where {
        show (N x) = &quot;(N &quot;++(if fromIntegral (floor x) == x then show (floor x) else show x)++&quot;)&quot;;
        show (F _) = &quot;(λ...)&quot;}
    infixl 0 #
    (F f) # x = f x
    churchNum = F(\(N n)-&gt;F(\f-&gt;F(\x-&gt;if n&lt;=0 then x else (f#(churchNum#(N(n-1))#f#x)))))
    expMod    = (F(\v0-&gt;(F(\v1-&gt;(F(\v2-&gt;((((((churchNum # v2) # (F(\v3-&gt;(F(\v4-&gt;(v3 # (F(\v5-&gt;((v4 # (F(\v6-&gt;(F(\v7-&gt;(v6 # ((v5 # v6) # v7))))))) # v5))))))))) # (F(\v3-&gt;(v3 # (F(\v4-&gt;(F(\v5-&gt;v5)))))))) # (F(\v3-&gt;((((churchNum # v1) # (churchNum # v0)) # ((((churchNum # v2) # (F(\v4-&gt;(F(\v5-&gt;(F(\v6-&gt;(v4 # (F(\v7-&gt;((v5 # v7) # v6))))))))))) # (F(\v4-&gt;v4))) # (F(\v4-&gt;(F(\v5-&gt;(v5 # v4))))))) # ((((churchNum # v2) # (F(\v4-&gt;(F(\v5-&gt;v4))))) # (F(\v4-&gt;v4))) # (F(\v4-&gt;v4))))))) # (F(\v3-&gt;(((F(\(N x)-&gt;F(\(N y)-&gt;N(x+y)))) # v3) # (N 1))))) # (N 0))))))))
    main = print $ (expMod # N 5 # N 5 # N 4)

This correctly outputs `1` (`5 ^ 5 % 4`) - but throw anything above `10^10` and it will be stuck, eliminating the hypothesis. 

The [optimal evaluator I used](https://github.com/SrVictorMaia/optlam) is a 160-lines long, unoptimized JavaScript program that didn&#39;t include any sort of exponential modulus math - and the lambda-calculus modulus function I used was equally simple:

    (λab.(b(λcd.(c(λe.(d(λfg.(f(efg)))e))))(λc.(c(λde.e)))(λc.(a(b(λdef.(d(λg.(egf))))(λd.d)(λde.(ed)))(b(λde.d)(λd.d)(λd.d))))))

I used no specific modular arithmetic algorithm or formula. **So, how is the optimal evaluator able to arrive at the right answers?**





Why are λ-calculus optimal evaluators able to compute big modular exponentiations without formulas?

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.

Profiling builds with Stack

Is it possible to upgrade `node` right in place, instead of manually installing the latest stable version? 

I have installed [node.js][1] version `5.0` with [```nvm```][2], but now I want to update it to `5.4`. I&#39;m trying to avoid having to manually reinstall all of my global packages (*e.g.* by running `npm install -g grunt-cli bower yo yoman-angular-generator blabla blablablabla`...).


  [1]: https://nodejs.org/en/
  [2]: https://github.com/creationix/nvm

Content Type	Original Author	Original Content on Stackoverflow
Question	Ben	View Question on Stackoverflow
Solution 1 - Haskell	user2913694	View Answer on Stackoverflow
Solution 2 - Haskell	Yuan Wang	View Answer on Stackoverflow
Solution 3 - Haskell	Nestor Tobon	View Answer on Stackoverflow

How to install a package using stack?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Solution 3 - Haskell

Multiple return statements without compiler error

'Malformed UTF-8 characters, possibly incorrectly encoded' in Laravel

Attributions