GHC only knows about packages that are installed. To see which packages are installed, use the ghc-pkg list command:

    $ ghc-pkg list
    /usr/lib/ghc-6.12.1/package.conf.d:
        Cabal-1.7.4
        array-0.2.0.1
        base-3.0.3.0
        base-4.2.0.0
        bin-package-db-0.0.0.0
        binary-0.5.0.1
        bytestring-0.9.1.4
        containers-0.2.0.1
        directory-1.0.0.2
        (dph-base-0.4.0)
        (dph-par-0.4.0)
        (dph-prim-interface-0.4.0)
        (dph-prim-par-0.4.0)
        (dph-prim-seq-0.4.0)
        (dph-seq-0.4.0)
        extensible-exceptions-0.1.1.0
        ffi-1.0
        filepath-1.1.0.1
        (ghc-6.12.1)
        ghc-prim-0.1.0.0
        haskeline-0.6.2
        haskell98-1.0.1.0
        hpc-0.5.0.2
        integer-gmp-0.1.0.0
        mtl-1.1.0.2
        old-locale-1.0.0.1
        old-time-1.0.0.1
        pretty-1.0.1.0
        process-1.0.1.1
        random-1.0.0.1
        rts-1.0
        syb-0.1.0.0
        template-haskell-2.4.0.0
        terminfo-0.3.1
        time-1.1.4
        unix-2.3.1.0
        utf8-string-0.3.4

I just followed the tutorial located at https://www.digitalocean.com/community/articles/how-to-install-linux-apache-mysql-php-lamp-stack-on-ubuntu while fixing multiple other errors that I came across along the way and I&#39;m stuck with one last error. When I log in to phpMyAdmin, there&#39;s a huge red error at the bottom saying &quot;The mcrypt extension is missing. Please check your PHP configuration.&quot;.
I installed everything listed in the tutorial on Ubuntu 13.10 via putty.

The mcrypt extension is missing. Please check your PHP configuration

What&#39;s the difference in calling  
`stopSelf()` , `stopSelf(int)` or `stopService(new Intent(this,MyServiceClass.class))`  
inside `onStartCommand()` ?

for example if I start the same services twice this way:

    ...
    Intent myIntent1 = new Intent(AndroidAlarmService.this, MyAlarmService.class);
    myIntent1.putExtra(&quot;test&quot;, 1); 
    Intent myIntent2 = new Intent(AndroidAlarmService.this, MyAlarmService.class);
    myIntent2.putExtra(&quot;test&quot;, 2);
    startService(myIntent1);
    startService(myIntent2);
    ...

 
And implement onStartCommand in this way:

    public int onStartCommand(Intent intent, int flags, int startId)
    {
    Toast.makeText(this, &quot;onStartCommand called &quot;+intent.getIntExtra(&quot;test&quot;, 0), Toast.LENGTH_LONG).show();
    stopService(new Intent(this,MyAlarmService.class));
    return START_NOT_STICKY;
    }

I get exactly the same behaviour with the three methods,
that is onDestroy will only be called after onStartCommand is executed twice.




stopSelf() vs stopSelf(int) vs stopService(Intent)

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 encounter a strange situation in GHCI, don't know if anyone observed similar case. For some module, when I have it in the search path both by <code>-package-conf</code>, and also by <code>-i</code>, GHCI fails when I try to import the module with <code>'module is not loaded: FooModule'</code>.
<ul>
<li><code>:module</code> loads it fine however</li>
<li>or I can do <code>:load FooModule</code>, <code>:m</code> to clear the import list, and then <code>import FooModule</code></li>
<li>or I can remove the path from <code>-i</code> and then it imports fine</li>
</ul>
Tracked this to be the <code>otherwise -> modNotLoadedError m loc</code> case in <a href="http://www.haskell.org/ghc/docs/7.4.1/html/libraries/ghc/src/GHC.html" target="_blank" rel="noopener noreferrer">GHC</a>, where <code>otherwise</code> ~ <code>modulePackageId = this_pkg</code> (the meaning of which I don't know).
This is not entirely systematic, there are some module which are both in package and source path, but can be imported.

I have seen people recommending pipes/conduit library for various lazy IO related tasks. What problem do these libraries solve exactly?

Also, when I try to use some hackage related libraries, it is highly likely there are three different versions. Example:

 - [attoparsec][1]
 - [pipes-attoparsec][2]
 - [attoparsec-conduit][3]

This confuses me. For my parsing tasks should I use attoparsec or pipes-attoparsec/attoparsec-conduit? What benefit do the pipes/conduit version give me as compared to the plain vanilla attoparsec?

  [1]: http://hackage.haskell.org/package/attoparsec
  [2]: http://hackage.haskell.org/package/pipes-attoparsec
  [3]: http://hackage.haskell.org/package/attoparsec-conduit

What is pipes/conduit trying to solve

Let&#39;s say I have this string literal with line breaks:

    file :: String
    file = &quot;the first line\nthe second line\nthe third line&quot;

Is there any way to write it like this?

    file :: String
    file = &quot;the first line
            the second line
            the third line&quot;

The attempt just above leads to this error:

    factor.hs:58:33:
        lexical error in string/character literal at character &#39;\n&#39;
    Failed, modules loaded: none.


How can I write multiline strings in Haskell?

# Current behavior

    Prelude&gt; show _
    
    &lt;interactive&gt;:7:6:
        Found hole ‘_’ with type: a0
        Where: ‘a0’ is an ambiguous type variable
        Relevant bindings include it :: String (bound at &lt;interactive&gt;:7:1)
        In the first argument of ‘show’, namely ‘_’
        In the expression: show _
        In an equation for ‘it’: it = show _

# Desired behavior

It would be nice if GHC would also tell me that the typed hole has the `Show` type class constraint.

# Misc

*GHC Version 7.8.1*

Is there a way to make GHC provide the type class constraints of typed holes?

I just read the following from [typeclassopedia][1] about the difference between `Monad` and `Applicative`. I can understand that there is no `join` in `Applicative`. But the following description looks vague to me and I couldn&#39;t figure out what exactly is meant by &quot;the result&quot; of a monadic computation/action. So, if I put a value into `Maybe`, which makes a monad, what is the result of this &quot;computation&quot;?

&gt; Let’s look more closely at the type of (&gt;&gt;=). The basic intuition is
&gt; that it combines two computations into one larger computation. The
&gt; first argument, m a, is the first computation. However, it would be
&gt; boring if the second argument were just an m b; then there would be no
&gt; way for the computations to interact with one another (actually, this
&gt; is exactly the situation with Applicative). So, the second argument to
&gt; (&gt;&gt;=) has type a -&gt; m b: a function of this type, given a result of
&gt; the first computation, can produce a second computation to be run.
&gt; ... Intuitively, it is this ability to use the output from previous
&gt; computations to decide what computations to run next that makes Monad
&gt; more powerful than Applicative. The structure of an Applicative
&gt; computation is fixed, whereas the structure of a Monad computation can
&gt; change based on intermediate results.


  [1]: http://www.haskell.org/haskellwiki/Typeclassopedia#Intuition_3 &quot;typeclassopedia&quot;

Is there a concrete example illustrating &quot;ability to use the output from previous computations to decide what computations to run next&quot;, which Applicative does not have?



Difference between Monad and Applicative in Haskell

Here&#39;s the scenario: I&#39;ve written some code with a type signature and GHC complains could not deduce x ~ y for some `x` and `y`. You can usually throw GHC a bone and simply add the isomorphism to the function constraints, but this is a bad idea for several reasons:

  1. It does not emphasize understanding the code.
  2. You can end up with 5 constraints where one would have sufficed (for example, if the 5 are implied by one more specific constraint)
  3. You can end up with bogus constraints if you&#39;ve done something wrong or if GHC is being unhelpful

I just spent several hours battling case 3. I&#39;m playing with [`syntactic-2.0`][1], and I was trying to define a domain-independent version of `share`, similar to the version defined in [`NanoFeldspar.hs`][2].

I had this:

    {-# LANGUAGE GADTs, FlexibleContexts, TypeOperators #-}
    import Data.Syntactic
    
    -- Based on NanoFeldspar.hs
    data Let a where
        Let :: Let (a :-&gt; (a -&gt; b) :-&gt; Full b)

    share :: (Let :&lt;: sup,
              Domain a ~ sup,
              Domain b ~ sup,
              SyntacticN (a -&gt; (a -&gt; b) -&gt; b) fi) 
          =&gt; a -&gt; (a -&gt; b) -&gt; a
    share = sugarSym Let

and GHC `could not deduce (Internal a) ~ (Internal b)`, which is certainly not what I was going for. So either I had written some code I didn&#39;t intend to (which required the constraint), or GHC wanted that constraint due to some other constraints I had written.

It turns out I needed to add `(Syntactic a, Syntactic b, Syntactic (a-&gt;b))` to the constraint list, none of which imply `(Internal a) ~ (Internal b)`. I basically stumbled upon the correct constraints; I still don&#39;t have a systematic way to find them.

My questions are:

  1. Why did GHC propose that constraint? Nowhere in syntactic is there a constraint `Internal a ~ Internal b`, so where did GHC pull that from?
  2. In general, what techniques can be used to trace the origin of a constraint which GHC believes it needs? Even for constraints that I *can* discover myself, my approach is essentially brute forcing the offending path by physically writing down recursive constraints. This approach is basically going down an infinite rabbit hole of constraints and is about the least efficient method I can imagine.

  [1]: https://hackage.haskell.org/package/syntactic-2.0
  [2]: https://github.com/emilaxelsson/syntactic/blob/2.0/examples/NanoFeldspar.hs

Techniques for Tracing Constraints

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.


Content Type	Original Author	Original Content on Stackoverflow
Question	ron	View Question on Stackoverflow
Solution 1 - Haskell	Sherwin Salubon	View Answer on Stackoverflow

GHCI can't load module if both package-conf and source path contains it

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

stopSelf() vs stopSelf(int) vs stopService(Intent)

The mcrypt extension is missing. Please check your PHP configuration

Attributions