You didn&#39;t say which version of GHC 7.6 you were using or include which extensions you have on, so I&#39;m guessing a bit. 

[This ticket](https://ghc.haskell.org/trac/ghc/ticket/7347) seems to answer your question 1, although I don&#39;t totally understand the problem myself. In your particular example, I think `SSet` isn&#39;t promotable because one of its arguments (`Symbol tpe`) is an associated type which brings with it the `SymbolSet` constraint.

If I move `Symbol` out of the class we get the type promoted, however now we get kind mismatch errors:

    {-# LANGUAGE DataKinds , TypeFamilies , GADTs , MultiParamTypeClasses #-}
    class SymbolSet tpe where
      -- data Symbol tpe :: *
    data Symbol tpe :: *
    -- ...

I can get the whole shebang to compile by adding kind signatures to `HasElem`:

    {-# LANGUAGE DataKinds , TypeFamilies , GADTs , MultiParamTypeClasses, FlexibleInstances  #-}
    class SymbolSet tpe where
    -- MOVED OUT OF CLASS:
    data Symbol tpe :: *
    
    data SSet tpe where
      Identity :: tpe -&gt; SSet tpe
      And :: SSet tpe -&gt; Symbol tpe -&gt; SSet tpe
    
    -- ADDED KIND SIGNATURES:
    class HasElem (a :: SSet *) (b :: Symbol *) where
    
    instance (SymbolSet tpe) =&gt; HasElem (And (Identity tpe) s) s
    instance (HasElem sset s) =&gt; HasElem (And sset s) s

I don&#39;t really understand your code so that may not work for you.

How can I identify the package/formula for a given file, or a listing of all of a package&#39;s owned files, in Homebrew?


How to find package for installed file in Brew?

I am creating a new maven project with `pom.xml` as below:-

    &lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
      xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd&quot;&gt;
      &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;
    
      &lt;groupId&gt;firstRestlet&lt;/groupId&gt;
      &lt;artifactId&gt;restlet1&lt;/artifactId&gt;
      &lt;version&gt;0.0.1-SNAPSHOT&lt;/version&gt;
      &lt;packaging&gt;war&lt;/packaging&gt;
    
      &lt;name&gt;restlet1&lt;/name&gt;
      &lt;url&gt;http://maven.apache.org&lt;/url&gt;
      &lt;repositories&gt;
    &lt;repository&gt;
       &lt;id&gt;maven-restlet&lt;/id&gt;
       &lt;name&gt;Public online Restlet repository&lt;/name&gt;
       &lt;url&gt;http://maven.restlet.org&lt;/url&gt;
    &lt;/repository&gt; 
    &lt;/repositories&gt;
      &lt;properties&gt;
        &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
      &lt;/properties&gt;
    
      &lt;dependencies&gt;
        &lt;dependency&gt;
          &lt;groupId&gt;junit&lt;/groupId&gt;
          &lt;artifactId&gt;junit&lt;/artifactId&gt;
          &lt;version&gt;3.8.1&lt;/version&gt;
          &lt;scope&gt;test&lt;/scope&gt;
        &lt;/dependency&gt;
      &lt;/dependencies&gt;
    &lt;/project&gt;

The problem which i am facing is that target war file is not getting generated.
On eclipse console after i ran this `pom.xml` what i found was goals missing in `pom.xml`.

**ECLIPSE CONSOLE MESSAGE:** 

    No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format &lt;plugin-prefix&gt;:&lt;goal&gt; or &lt;plugin-group-id&gt;:&lt;plugin-artifact-id&gt;[:&lt;plugin-version&gt;]:&lt;goal&gt;. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -&gt; [Help 1]
    [ERROR] 

Please tell me how to specify goals in `pom.xml`.

Also tell me how to create RESTLET project using maven as build tool.

Thanks &amp; Regards,

specifying goal in pom.xml

I had this code:

    class SymbolSet tpe where
      data Symbol tpe :: *
     
    data SSet tpe where
      Identity :: tpe -&gt; SSet tpe
      And :: SSet tpe -&gt; Symbol tpe -&gt; SSet tpe
     
    class HasElem a b where
     
    instance (SymbolSet tpe) =&gt; HasElem (And (Identity tpe) s) s
    instance (HasElem sset s) =&gt; HasElem (And sset s) s

which was compiling in GHC-7.4. However on moving to GHC-7.6 it started giving compilation errors:

    &#39;And&#39; of tpe `forall tpe. tpe -&gt; Symbol * tpe -&gt; SSet tpe&#39; is not promotable

on digging through the docs, I found a new clause added to &quot;Datatype Promotion&quot; pages in [GHC-7.6][1] vs [GHC-7.4][2]

&gt; We do not promote datatypes whose constructors are kind polymorphic,
&gt; involve constraints, or use existential quantification.

My question is: 

 1. What is the rationale behind not promoting such constructors? 
 2. What would be the correct way of doing it?


  [1]: http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/promotion.html#id621045
  [2]: http://www.haskell.org/ghc/docs/7.4.2/html/users_guide/kind-polymorphism-and-promotion.html#promotion

Data Constructor promotion in GHC-7.6

I had this code:
<pre><code class="hljs language-csharp">class SymbolSet tpe where
 data Symbol tpe :: *
 
data SSet tpe where
 Identity :: tpe -> SSet tpe
 And :: SSet tpe -> Symbol tpe -> SSet tpe
 
class HasElem a b where
 
instance (SymbolSet tpe) => HasElem (And (Identity tpe) s) s
instance (HasElem sset s) => HasElem (And sset s) s
</code></pre>
which was compiling in GHC-7.4. However on moving to GHC-7.6 it started giving compilation errors:
<pre><code class="hljs language-rust">'And' of tpe `forall tpe. tpe -> Symbol * tpe -> SSet tpe' is not promotable
</code></pre>
on digging through the docs, I found a new clause added to "Datatype Promotion" pages in <a href="http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/promotion.html#id621045" target="_blank" rel="noopener noreferrer">GHC-7.6</a> vs <a href="http://www.haskell.org/ghc/docs/7.4.2/html/users_guide/kind-polymorphism-and-promotion.html#promotion" target="_blank" rel="noopener noreferrer">GHC-7.4</a>
> We do not promote datatypes whose constructors are kind polymorphic,
> involve constraints, or use existential quantification.
My question is:
<ol>
<li>What is the rationale behind not promoting such constructors?</li>
<li>What would be the correct way of doing it?</li>
</ol>

I have seen a lot of functions being defined according to the pattern `(f .) . g`. For example:

    countWhere = (length .) . filter
    duplicate  = (concat .) . replicate
    concatMap  = (concat .) . map

What does this mean?

What does (f .) . g mean in Haskell?

I&#39;m new to haskell and working on unit testing, however I find the ecosystem to be very confusing.  I&#39;m confused as to the relationship between HTF and HUnit.  

In some examples I see you set up test cases, export them in an tests list, and then run in ghci with `runTestsTT` (like [this HUnit example][1]). 

In other examples, you create a test runner tied into the cabal file that uses some preprocessor magic to find your tests like in this [git example][2].  Also it seems that HTF tests need to be prefixed with `test_` or they aren&#39;t run? I had a hard time finding any documentation on that, I just noticed the pattern that everyone had.

Anyways, can someone help sort this out for me? What is considered the standard way of doing things in Haskell? What are the best practices? What is the easiest to set up and maintain? 


  [1]: http://hunit.sourceforge.net/HUnit-1.0/Guide.html
  [2]: https://github.com/skogsbaer/HTF/blob/master/sample/TestMain.hs

Haskell unit testing

How can I get esqueleto to generate an SQL string from a `from` statement?

The documentation of `toRawSql` says that &quot;you may just turn on query logging of persistent&quot;.  I tried all possible forms of `MonadLogger` that I could understand, but it never printed any SQL.  The same documentation also says &quot;manually using this function ... is possible but tedious&quot;.  However, no constructors of the type, nor any functions returning values of the type, `QueryType` are exported.  I managed to get around this by noticing that `QueryType` is a `newtype` and using `unsafeCoerce`!

I was also forced to provide a `Connection` (which I got via SQLite) even though there should be no need to connect to a database to generate the SQL.

This is what I&#39;ve got.  There must be a better way.

    withSqliteConn &quot;:memory:&quot; $
        \conn -&gt; return $ toRawSql SELECT
                                   (unsafeCoerce ((const mempty)
                                      :: a -&gt; Text.Lazy.Builder.Builder))
                                   (conn, initialIdentState) myFromStatement)

http://hackage.haskell.org/package/esqueleto-1.3.4.2/docs/Database-Esqueleto-Internal-Sql.html

How can I get esqueleto to generate an SQL string for me?

I am trying to find an explanation of the DataKinds extension that will make sense to me having come from only having read [Learn You a Haskell][1]. Is there a standard source that will make sense to me with what little I&#39;ve learned?

Edit: For example the [documentation][2] says

&gt; With -XDataKinds, GHC automatically promotes every suitable datatype
&gt; to be a kind, and its (value) constructors to be type constructors.
&gt; The following types

and  gives the example

    data Nat = Ze | Su Nat

give rise to the following kinds and type constructors:

    Nat :: BOX
    Ze :: Nat
    Su :: Nat -&gt; Nat

I am not getting the point. Although I don&#39;t understand what `BOX` means, the statements `Ze :: Nat` and `Su :: Nat -&gt; Nat` seem to state what is already normally the case that Ze and Su are normal data constructors exactly as you would expect to see with ghci

    Prelude&gt; :t Su
    Su :: Nat -&gt; Nat


  [1]: http://learnyouahaskell.com/
  [2]: http://www.haskell.org/ghc/docs/7.6.2/html/users_guide/promotion.html

What is the DataKinds extension of Haskell?

I have a moderately sized application that uses `Data.Acid` for persistence and I&#39;ve encountered a situation where I need to update the implementation of one of my `Update` events for the next version of the server. I.e. I have something like

    myUpdate :: Update MyState ()
    myUpdate = &lt;some outdated implementation&gt;

Now, obviously I can&#39;t just change the implementation haphazardly as it would corrupt my transaction history, so I was wondering how people usually handle this. The way I see it my options are:

1. Stop the server. Run `createCheckpoint` for my `AcidState`. Update the `Event` implementation and then restart the server. Since we load from a fresh snapshot, the changed `Update` should never trigger for the old events.

2. Create a a new `Update` with a new name (like `myUpdate_v2`) and update my server logic to only use `myUpdate_v2` everywhere instead of the original `myUpdate`.

I think both options have their merits. (1) is nicer since I don&#39;t need to retain the old functionality in my codebase but it has to be done very carefully for each server I update or I risk corrupting data. (2) is safer (especially if I remove the old `myUpdate` from my module&#39;s exports so I can be sure I don&#39;t accidentally use the old implementation anywhere), but it feels a bit ugly otherwise.

Is there some better way of doing this? I see this as something I will definitely encounter every then and again in a long-lived project so I would like to have a good, standard workflow for applying changes to the implementation of my events.

How to handle changing the implementation of Events when using Data.Acid

I&#39;m trying to use Kotlin in my Android project. I need to create custom view class. Each custom view has two important constructors:

    public class MyView extends View {
        public MyView(Context context) {
            super(context);
        }
    
        public MyView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }
    }

`MyView(Context)` is used to instantiate view in code, and `MyView(Context, AttributeSet)` is called by layout inflater when inflating layout from XML.

Answer to [this question][1] suggests that I use constructor with default values or factory method. But here&#39;s what we have:

**Factory method:**

    fun MyView(c: Context) = MyView(c, attrs) //attrs is nowhere to get
    class MyView(c: Context, attrs: AttributeSet) : View(c, attrs) { ... }

or  

    fun MyView(c: Context, attrs: AttributeSet) = MyView(c) //no way to pass attrs.
                                                            //layout inflater can&#39;t use 
                                                            //factory methods
    class MyView(c: Context) : View(c) { ... }

**Constructor with default values:**

    class MyView(c: Context, attrs: AttributeSet? = null) : View(c, attrs) { ... }
    //here compiler complains that 
    //&quot;None of the following functions can be called with the arguments supplied.&quot;
    //because I specify AttributeSet as nullable, which it can&#39;t be.
    //Anyway, View(Context,null) is not equivalent to View(Context,AttributeSet)

**How can this puzzle be resolved?**

----------

**UPDATE:** Seems like we can use `View(Context, null)` superclass constructor instead of `View(Context)`, so factory method approach seems to be the solution. But even then I can&#39;t get my code to work:

    fun MyView(c: Context) = MyView(c, null) //compilation error here, attrs can&#39;t be null
    class MyView(c: Context, attrs: AttributeSet) : View(c, attrs) { ... }

or 

    fun MyView(c: Context) = MyView(c, null) 
    class MyView(c: Context, attrs: AttributeSet?) : View(c, attrs) { ... }
    //compilation error: &quot;None of the following functions can be called with 
    //the arguments supplied.&quot; attrs in superclass constructor is non-null

  [1]: https://stackoverflow.com/questions/19299525/kotlin-secondary-constructor/19310740

How to create constructor of custom view with Kotlin

I can not understand why the constructor is executed with the parameter `Double[]`?

    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
     
    namespace MyConsoleApp
    {
        class Program
        {
            static void Main(string[] args)
            {
                D myD = new D(null);
                Console.ReadLine();           
            }
            
        }
        
        public class D
        {
            public D(object o)
            {
                Console.WriteLine(&quot;Object&quot;);
            }
            public D(double[] array)
            {
                Console.WriteLine(&quot;Array&quot;);
            }
            public D(int i)
            {
                Console.WriteLine(&quot;Int&quot;);
            }
        }
    }

I think because the first constructor takes a parameter of reference type. The first constructor with a reference parameter because `null` is the default value for reference types. 

But i don&#39;t understand why not `object`, it&#39;s also a reference type.

Transfer NULL to the constructor

I&#39;ve noticed it&#39;s possible to create a const constructor in Dart. In the documentation, it says that `const` word is used to denote something a compile time constant. 

I was wondering what happens when I use a `const` constructor to create an object. Is this like an immutable object which is always the same and available at compile time? How does the concept of `const` constructor actually work? How is a **const** constructor different from a **regular** constructor?

How does the const constructor actually work?

**Summary**: I would like to call an asynchronous method in a constructor. Is this possible?

**Details**: I have a method called `getwritings()` that parses JSON data. Everything works fine if I just call `getwritings()` in an `async` method and put `await` to left of it. However , when I create a `LongListView` in my page and try to populate it I&#39;m finding that `getWritings()` is surprisingly returning `null` and the `LongListView` is empty.

To address this problem, I tried changing the return type of `getWritings()` to `Task&lt;List&lt;Writing&gt;&gt;` and then retrieving the result in the constructor via `getWritings().Result`. However, doing that ends up **blocking the UI thread.**
    
    public partial class Page2 : PhoneApplicationPage
    {
        List&lt;Writing&gt; writings;
 
	    public Page2()
	    {
	        InitializeComponent();
	        getWritings();
	    }
 
	    private async void getWritings()
	    {
	        string jsonData = await JsonDataManager.GetJsonAsync(&quot;1&quot;);
	        JObject obj = JObject.Parse(jsonData);
	        JArray array = (JArray)obj[&quot;posts&quot;];
 
	        for (int i = 0; i &lt; array.Count; i++)
	        {
	            Writing writing = new Writing();
	            writing.content = JsonDataManager.JsonParse(array, i, &quot;content&quot;);
                writing.date = JsonDataManager.JsonParse(array, i, &quot;date&quot;);
	            writing.image = JsonDataManager.JsonParse(array, i, &quot;url&quot;);
	            writing.summary = JsonDataManager.JsonParse(array, i, &quot;excerpt&quot;);
	            writing.title = JsonDataManager.JsonParse(array, i, &quot;title&quot;);
 
	            writings.Add(writing);
	        }
 
	        myLongList.ItemsSource = writings;
	    }
	}


Call asynchronous method in constructor?

I am getting an undefined reference to `vtable for student&#39; while compiling the following header file:

student.h

    class student
    {
    private:
        string names;
        string address;
        string type;
    
    protected:
        float marks;
        int credits;
    
    public:
        student();
        student(string n,string a,string t,float m);
        ~student();
        string getNames();
        string getAddress();
        string getType();
        float getMarks();
        virtual void calculateCredits();
        int getCredits();
    };
    
    student::student(){}
    
    student::student(string n, string a,string t,float m)
    {
        names = n;
        address = a;
        marks = m;
    }
    
    student::~student(){}

I can&#39;t find what is wrong in this.

undefined reference to &#39;vtable for class&#39; constructor

I&#39;m having problems getting GHC to specialize a function with a class constraint. I have a minimal example of my problem here: [Foo.hs][1] and  [Main.hs][2]. The two files compile (GHC 7.6.2, `ghc -O3 Main`) and run.

**NOTE:**
`Foo.hs` is really stripped down. If you want to see why the constraint is needed, you can see a little more code [here][3]. If I put the code in a single file or make many other minor changes, GHC simply inlines the call to `plusFastCyc`. This will not happen in the real code because `plusFastCyc` is too large for GHC to inline, even when marked `INLINE`. The point is to _specialize_ the call to `plusFastCyc`, not inline it. `plusFastCyc` is called in many places in the real code, so duplicating such a large function would not be desirable even if I could force GHC to do it.


The code of interest is the `plusFastCyc` in `Foo.hs`, reproduced here:
    
    {-# INLINEABLE plusFastCyc #-}
    {-# SPECIALIZE plusFastCyc :: 
             forall m . (Factored m Int) =&gt; 
                  (FastCyc (VT U.Vector m) Int) -&gt; 
                       (FastCyc (VT U.Vector m) Int) -&gt; 
                            (FastCyc (VT U.Vector m) Int) #-}
    
    -- Although the next specialization makes `fcTest` fast,
    -- it isn&#39;t useful to me in my real program because the phantom type M is reified
    -- {-# SPECIALIZE plusFastCyc :: 
    --          FastCyc (VT U.Vector M) Int -&gt; 
    --               FastCyc (VT U.Vector M) Int -&gt; 
    --                    FastCyc (VT U.Vector M) Int #-}

    plusFastCyc :: (Num (t r)) =&gt; (FastCyc t r) -&gt; (FastCyc t r) -&gt; (FastCyc t r)
    plusFastCyc (PowBasis v1) (PowBasis v2) = PowBasis $ v1 + v2

The `Main.hs` file has two drivers: `vtTest`, which runs in ~3 seconds, and `fcTest`, which runs in ~83 seconds when compiled with -O3 using the `forall`&#39;d specialization.

The [core shows][4] that for the `vtTest` test, the addition code is being specialized to `Unboxed` vectors over `Int`s, etc, while generic vector code is used for `fcTest`.
On line 10, you can see that GHC does write a specialized version of `plusFastCyc`, compared to the generic version on line 167.
The rule for the specialization is on line 225. I believe this rule should fire on line 270. (`main6` calls `iterate main8 y`, so `main8` is where `plusFastCyc` should be specialized.)






My goal is to make `fcTest` as fast as `vtTest` by specializing `plusFastCyc`. I&#39;ve found two ways to do this:

 1. Explicity call `inline` from `GHC.Exts` in `fcTest`.
 2. Remove the `Factored m Int` constraint on `plusFastCyc`.

Option 1 is unsatisfactory because in the actual code base `plusFastCyc` is a frequently used operation and a *very* large function, so it should not be inlined at every use. Rather, GHC should call a specialized version of `plusFastCyc`. Option 2 is not really an option because I need the constraint in the real code.

I&#39;ve tried a variety of options using (and not using) `INLINE`, `INLINABLE`, and `SPECIALIZE`, but nothing seems to work. (**EDIT**: I may have stripped out too much of `plusFastCyc` to make my example small, so `INLINE` might cause the function to be inlined. This doesn&#39;t happen in my real code because `plusFastCyc` is so large.) In this particular example, I&#39;m not getting any [`match_co: needs more cases`][5] or [`RULE: LHS too complicated to desugar`][6] (and [here][7]) warnings, though I was getting many `match_co` warnings before minimizing the example. Presumably, the &quot;problem&quot; is the `Factored m Int` constraint in the rule; if I make changes to that constraint, `fcTest` runs as fast as `vtTest`.

Am I doing something GHC just doesn&#39;t like? Why won&#39;t GHC specialize the `plusFastCyc`, and how can I make it?

**UPDATE**

The problem persists in GHC 7.8.2, so this question is still relevant.

  [1]: http://lpaste.net/98464
  [2]: http://lpaste.net/98342
  [3]: http://lpaste.net/98840
  [4]: http://lpaste.net/98593
  [5]: http://web.archiveorange.com/archive/v/2B0uXzyXUnvOzzIApVfp
  [6]: https://stackoverflow.com/questions/18792388/haskell-ghc-specialize-causes-rule-left-hand-side-too-complicated-to
  [7]: https://ghc.haskell.org/trac/ghc/ticket/5821
  [8]: http://www.haskell.org/ghc/docs/7.6.2/html/users_guide/pragmas.html

Specialization with Constraints

From [the docs][1] for GHC 7.6:

&gt; [Y]ou often don&#39;t even need the SPECIALIZE pragma in the first place. When compiling a module M, GHC&#39;s optimiser (with -O) automatically considers each top-level overloaded function declared in M, and specialises it for the different types at which it is called in M. The optimiser also considers each imported INLINABLE overloaded function, and specialises it for the different types at which it is called in M.

and

&gt; Moreover, given a SPECIALIZE pragma for a function f, GHC will automatically create specialisations for any type-class-overloaded functions called by f, if they are in the same module as the SPECIALIZE pragma, or if they are INLINABLE; and so on, transitively.

So GHC should automatically specialize [some/most/all(?)][2] functions marked `INLINABLE` *without* a pragma, and if I use an explicit pragma, the specialization is transitive. My question is: 
is the *auto*-specialization transitive?

Specifically, here&#39;s a small example:

Main.hs:

    import Data.Vector.Unboxed as U
    import Foo
    
    main =
        let y = Bar $ Qux $ U.replicate 11221184 0 :: Foo (Qux Int)
            (Bar (Qux ans)) = iterate (plus y) y !! 100
        in putStr $ show $ foldl1&#39; (*) ans

Foo.hs:

    module Foo (Qux(..), Foo(..), plus) where
    
    import Data.Vector.Unboxed as U
    
    newtype Qux r = Qux (Vector r)
    -- GHC inlines `plus` if I remove the bangs or the Baz constructor
    data Foo t = Bar !t
               | Baz !t
    
    instance (Num r, Unbox r) =&gt; Num (Qux r) where
        {-# INLINABLE (+) #-}
        (Qux x) + (Qux y) = Qux $ U.zipWith (+) x y
    
    {-# INLINABLE plus #-}
    plus :: (Num t) =&gt; (Foo t) -&gt; (Foo t) -&gt; (Foo t)
    plus (Bar v1) (Bar v2) = Bar $ v1 + v2

GHC specializes the call to `plus`, but does *not* specialize `(+)` in the `Qux` `Num` instance which kills performance. 

However, an explicit pragma 
 
    {-# SPECIALIZE plus :: Foo (Qux Int) -&gt; Foo (Qux Int) -&gt; Foo (Qux Int) #-}

results in *transitive* specialization as the docs indicate, so `(+)` is specialized and the code is 30x faster (both compiled with `-O2`). Is this expected behavior? Should I only expect `(+)` to be specialized transitively with an explicit pragma?

----
**UPDATE**

The docs for 7.8.2 haven&#39;t changed, and the behavior is the same, so this question is still relevant.


  [1]: http://www.haskell.org/ghc/docs/7.6.3/html/users_guide/pragmas.html#idp49866112
  [2]: https://stackoverflow.com/questions/21071706/specialization-with-constraints

Transitivity of Auto-Specialization in GHC

# 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?

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;ve recently posted a [question][1] about [syntactic-2.0][2] regarding the definition of `share`. I&#39;ve had this working in **GHC 7.6**:

    {-# LANGUAGE GADTs, TypeOperators, FlexibleContexts #-}
    
    import Data.Syntactic
    import Data.Syntactic.Sugar.BindingT
    
    data Let a where
        Let :: Let (a :-&gt; (a -&gt; b) :-&gt; Full b)
    
    share :: (Let :&lt;: sup,
              sup ~ Domain b, sup ~ Domain a,
              Syntactic a, Syntactic b,
              Syntactic (a -&gt; b),
              SyntacticN (a -&gt; (a -&gt; b) -&gt; b) 
                         fi)
               =&gt; a -&gt; (a -&gt; b) -&gt; b
    share = sugarSym Let

However, GHC 7.8 wants `-XAllowAmbiguousTypes` to compile with that signature. Alternatively, I can replace the `fi` with 

    (ASTF sup (Internal a) -&gt; AST sup ((Internal a) :-&gt; Full (Internal b)) -&gt; ASTF sup (Internal b))

which is the type implied by the fundep on `SyntacticN`. This allows me to avoid the extension. Of course this is 

 - a very long type to add to an already-large signature
 - tiresome to manually derive
 - unnecessary due to the fundep

My questions are:

  1. Is this an acceptable use of `-XAllowAmbiguousTypes`?
  2. In general, when should this extension be used? An answer [here][3] suggests &quot;it is almost never a good idea&quot;.
  3. Though I&#39;ve read [the docs][4], I&#39;m still having trouble deciding if a constraint is ambiguous or not. Specifically, consider this function from Data.Syntactic.Sugar:

        sugarSym :: (sub :&lt;: AST sup, ApplySym sig fi sup, SyntacticN f fi) 
                 =&gt; sub sig -&gt; f
        sugarSym = sugarN . appSym
    
   It appears to me that `fi` (and possibly `sup`) should be ambiguous here, but it compiles without the extension. Why is `sugarSym` unambiguous while `share` is? Since `share` is an application of `sugarSym`, the `share` constraints all come straight from `sugarSym`.


  [1]: https://stackoverflow.com/questions/23448150/techniques-for-tracing-constraints
  [2]: https://github.com/emilaxelsson/syntactic
  [3]: https://stackoverflow.com/questions/23461560/how-can-i-extract-this-polymorphic-recursion-function/23462397#23462397
  [4]: http://www.haskell.org/ghc/docs/7.8.2/html/users_guide/other-type-extensions.html#ambiguity

Content Type	Original Author	Original Content on Stackoverflow
Question	rabisg	View Question on Stackoverflow
Solution 1 - Haskell	jberryman	View Answer on Stackoverflow

Data Constructor promotion in GHC-7.6

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

specifying goal in pom.xml

How to find package for installed file in Brew?

Attributions