These are GHC-specific extensions of the Haskell kind system. The Haskell 98 report [specifies only a simple kind system][1]:

&gt; ... type expressions are classified
&gt; into different kinds, which take one
&gt; of two possible forms:
&gt; 
&gt; The symbol * represents the kind of
&gt; all nullary type constructors. If k1
&gt; and k2 are kinds, then k1-&gt;k2 is the
&gt; kind of types that take a type of kind
&gt; k1 and return a type of kind k2.

GHC [extends this system][2] with a form of kind subtyping, to allow [unboxed types][3], and to allow the function construtor to be polymorphic over kinds. The kind lattice GHC supports is:

                 ?
                 /\
                /  \
              ??   (#)
              / \     
             *   #     

    Where:       *   [LiftedTypeKind]   means boxed type
                 #   [UnliftedTypeKind] means unboxed type
                (#)  [UbxTupleKind]     means unboxed tuple
                ??   [ArgTypeKind]      is the lub of {*, #}
                ?    [OpenTypeKind]     means any type at all

Defined in [ghc/compiler/types/Type.lhs][4]

In particular:

    &gt; error :: forall a:?. String -&gt; a
    &gt; (-&gt;)  :: ?? -&gt; ? -&gt; *
    &gt; (\\(x::t) -&gt; ...)

Where in the last example `t :: ??` (i.e. is not an unboxed tuple). So, to quote GHC, &quot;there is a little subtyping at the kind level&quot;.

For interested souls, GHC also supports coercion types and kinds (&quot;type-level terms which act as evidence for type equalities&quot;, as needed by [System Fc][5]) used in GADTs, newtypes and type families.


  [1]: http://www.haskell.org/onlinereport/decls.html#sect4.1.1
  [2]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.50.231
  [3]: http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/primitives.html#glasgow-unboxed
  [4]: http://darcs.haskell.org/ghc/compiler/types/Type.lhs
  [5]: http://www.cse.unsw.edu.au/~chak/papers/SCPD07.html

I have few columns in my DataGridView, and there is data in my rows. I saw few solutions in here, but I can not combine them!

Simply a way to right-click on a row, it will select the whole row and show a menu with an option to delete the row and when the option selected it will delete the row.

I made few attempts but none is working and it looks messy. What should I do?


Right click to select a row in a Datagridview and show a menu to delete it

I&#39;m seriously confused about the concept of the &#39;Model&#39; in MVC.  Most frameworks that exist today put the Model between the Controller and the database, and the Model almost acts like a database abstraction layer.  The concept of &#39;Fat Model Skinny Controller&#39; is lost as the Controller starts doing more and more logic.

In DDD, there is also the concept of a Domain Entity, which has a unique identity to it.  As I understand it, a user is a good example of an Entity (unique userid, for instance).  The Entity has a life-cycle -- it&#39;s values can change throughout the course of the action -- and then it&#39;s saved or discarded.

The Entity I describe above is what I thought Model was supposed to be in MVC?  How off-base am I?

To clutter things more, you throw in other patterns, such as the Repository pattern (maybe putting a Service in there).  It&#39;s pretty clear how the Repository would interact with an Entity -- how does it with a Model?

Controllers can have multiple Models, which makes it seem like a Model is less a &quot;database table&quot; than it is a unique Entity.

**UPDATE:** [In this post][1] the Model is described as something with knowledge, and it can be singular or a collection of objects.  So it&#39;s sound more like an Entity and a Model are more or less the same.  The Model is an all encompassing term, where an Entity is more specific.  A Value Object would be a Model as well.  At least in terms of MVC.  Maybe???

So, in very rough terms, which is better?

No &quot;Model&quot; really ...

    class MyController {
        public function index() {
            $repo = new PostRepository();
            $posts = $repo-&gt;findAllByDateRange(&#39;within 30 days&#39;);
            foreach($posts as $post) {
                echo $post-&gt;Author;
            }
        }
    }

Or this, which has a Model as the DAO?

    class MyController {
        public function index() {
            $model = new PostModel();
            // maybe this returns a PostRepository?
            $posts = $model-&gt;findAllByDateRange(&#39;within 30 days&#39;);
            while($posts-&gt;getNext()) {
                echo $posts-&gt;Post-&gt;Author;
            }
        }
    }

Both those examples didn&#39;t even do what I was describing above.  I&#39;m clearly lost.  Any input?


  [1]: http://www.codinghorror.com/blog/2008/05/understanding-model-view-controller.html

DDD and MVC: Difference between &#39;Model&#39; and &#39;Entity&#39;

When I was experimenting with Haskell kinds, and trying to get the kind of `-&gt;`, and this showed up:

    $ ghci
    ...
    Prelude&gt; :k (-&gt;)
    (-&gt;) :: ?? -&gt; ? -&gt; *
    Prelude&gt; 

Instead of the expected `* -&gt; * -&gt; *`.
What are the `??` and `?` things? Do they mean concrete types or &quot;kind variables&quot;? Or something else?


Haskell Weird Kinds: Kind of (-&gt;) is ?? -&gt; ? -&gt; *

When I was experimenting with Haskell kinds, and trying to get the kind of <code>-></code>, and this showed up:
<pre><code class="hljs language-rust">$ ghci
...
Prelude> :k (->)
(->) :: ?? -> ? -> *
Prelude> 
</code></pre>
Instead of the expected <code>* -> * -> *</code>.
What are the <code>??</code> and <code>?</code> things? Do they mean concrete types or "kind variables"? Or something else?

I read that hash tables in Haskell had performance issues (on the [Haskell-Cafe][1] in 2006 and [Flying Frog Consultancy&#39;s blog][2] in 2009), and since I like Haskell it worried me.

That was a year ago, what is the status now (June 2010)? Has the &quot;hash table problem&quot; been fixed in GHC?


  [1]: http://thread.gmane.org/gmane.comp.lang.haskell.cafe/11070
  [2]: http://flyingfrogblog.blogspot.com/2009/04/f-vs-ocaml-vs-haskell-hash-table.html

Curious about the HashTable performance issues

What&#39;s the status of multicore programming in Haskell? What projects, tools, and libraries are available now? What experience reports have there been?

What&#39;s the status of multicore programming in Haskell?

I&#39;m beginning to understand how the `forall` keyword is used in so-called &quot;existential types&quot; like this:

    data ShowBox = forall s. Show s =&gt; SB s

This is only a subset, however, of how `forall` is used and I simply cannot wrap my mind around its use in things like this:

    runST :: forall a. (forall s. ST s a) -&gt; a

Or explaining why these are different:

    foo :: (forall a. a -&gt; a) -&gt; (Char, Bool)
    bar :: forall a. ((a -&gt; a) -&gt; (Char, Bool))

Or the whole `RankNTypes` stuff...

I tend to prefer clear, jargon-free English rather than the kinds of language which are normal in academic environments.  Most of the explanations I attempt to read on this (the ones I can find through search engines) have these problems:

 1. They&#39;re incomplete.  They explain one part of the use of this keyword (like &quot;existential types&quot;) which makes me feel happy until I read code that uses it in a completely different way (like `runST`, `foo` and `bar` above).
 2. They&#39;re densely packed with assumptions that I&#39;ve read the latest in whatever branch of discrete math, category theory or abstract algebra is popular this week.  (If I never read the words &quot;consult the paper *whatever* for details of implementation&quot; again, it will be too soon.)
 3. They&#39;re written in ways that frequently turn even simple concepts into tortuously twisted and fractured grammar and semantics.

So...

On to the actual question.  Can anybody completely explain the `forall` keyword in clear, plain English (or, if it exists somewhere, point to such a clear explanation which I&#39;ve missed) that doesn&#39;t assume I&#39;m a mathematician steeped in the jargon?

-----

*Edited to add:*

There were two stand-out answers from the higher-quality ones below, but unfortunately I can only choose one as best.  [Norman&#39;s answer](https://stackoverflow.com/questions/3071136/what-does-the-forall-keyword-in-haskell-ghc-do/3071365#3071365) was detailed and useful, explaining things in a way that showed some of the theoretical underpinnings of `forall` and at the same time showing me some of the practical implications of it.  [yairchu&#39;s answer](https://stackoverflow.com/questions/3071136/what-does-the-forall-keyword-in-haskell-ghc-do/3071932#3071932) covered an area nobody else mentioned (scoped type variables) and illustrated all of the concepts with code and a GHCi session.  Were it possible to select both as best, I would.  Unfortunately I can&#39;t and, after looking over both answers closely, I&#39;ve decided that yairchu&#39;s slightly edges out Norman&#39;s because of the illustrative code and attached explanation.  This is a bit unfair, however, because really I needed both answers to understand this to the point that `forall` doesn&#39;t leave me with a faint sense of dread when I see it in a type signature.

What does the `forall` keyword in Haskell/GHC do?

What is a good way to design/structure large functional programs, especially in Haskell?

I&#39;ve been through a bunch of the tutorials (Write Yourself a Scheme being my favorite, with Real World Haskell a close second) - but most of the programs are relatively small, and single-purpose.  Additionally, I don&#39;t consider some of them to be particularly elegant (for example, the vast lookup tables in WYAS).

I&#39;m now wanting to write larger programs, with more moving parts - acquiring data from a variety of different sources, cleaning it, processing it in various ways, displaying it in user interfaces, persisting it, communicating over networks, etc.  How could one best structure such code to be legible, maintainable, and adaptable to changing requirements?

There is quite a large literature addressing these questions for large object-oriented imperative programs. Ideas like MVC, design patterns, etc. are decent prescriptions for realizing broad goals like separation of concerns and reusability in an OO style.  Additionally, newer imperative languages lend themselves to a &#39;design as you grow&#39; style of refactoring to which, in my novice opinion, Haskell appears less well-suited.

Is there an equivalent literature for Haskell?  How is the zoo of exotic control structures available in functional programming (monads, arrows, applicative, etc.) best employed for this purpose? What best practices could you recommend?

Thanks!

EDIT (this is a follow-up to Don Stewart&#39;s answer):

@dons mentioned: &quot;Monads capture key architectural designs in types.&quot;

I guess my question is: how should one think about key architectural designs in a pure functional language?

Consider the example of several data streams, and several processing steps.  I can write modular parsers for the data streams to a set of data structures, and I can implement each processing step as a pure function.  The processing steps required for one piece of data will depend on its value and others&#39;.  Some of the steps should be followed by side-effects like GUI updates or database queries.

What&#39;s the &#39;Right&#39; way to tie the data and the parsing steps in a nice way?  One could write a big function which does the right thing for the various data types.  Or one could use a monad to keep track of what&#39;s been processed so far and have each processing step get whatever it needs next from the monad state.  Or one could write largely separate programs and send messages around (I don&#39;t much like this option).

The slides he linked have a Things we Need bullet: &quot;Idioms for mapping design onto 
types/functions/classes/monads&quot;.  What are the idioms? :)


Large-scale design in Haskell?

When compiling my Haskell application with the &lt;code&gt;-Wall&lt;/code&gt; option, GHC complains about orphaned instances, for example:

    Publisher.hs:45:9:
        Warning: orphan instance: instance ToSElem Result

The type class &lt;code&gt;ToSElem&lt;/code&gt; is not mine, it&#39;s defined by [HStringTemplate][1].

Now I know how to fix this (move the instance declaration into the module where Result is declared), and I know [why GHC would prefer to avoid orphaned instances][2], but I still believe that my way is better.  I don&#39;t care if the compiler is inconvenienced - rather it than me.

The reason I want to declare my &lt;code&gt;ToSElem&lt;/code&gt; instances in the Publisher module is because it is the Publisher module that depends on HStringTemplate, not the other modules.  I am trying to maintain a separation of concerns and avoid having every module depend on HStringTemplate.

I thought that one of the advantages of Haskell&#39;s type classes, when compared for example to Java&#39;s interfaces, is that they are open rather than closed and therefore the instances do not have to be declared in the same place as the data type.  GHC&#39;s advice seems to be to ignore this.

So, what I&#39;m looking for is either some validation that my thinking is sound and that I would be justified in ignoring/suppressing this warning, or a more convincing argument against doing things my way.


  [1]: http://www.haskell.org/haskellwiki/HStringTemplate
  [2]: http://www.haskell.org/ghc/docs/6.10.3/html/users_guide/separate-compilation.html#orphan-modules

Orphaned instances in Haskell

How to I define the equivalent of this function (taken from [learnyouahaskell][1]) inside GHCi?

    import Data.List  
  
    numUniques :: (Eq a) =&gt; [a] -&gt; Int  
    numUniques = length . nub  

Without the type declaration, GHCi accepts the function definition, but it ends up with an unhelpful type:

    Prelude Data.List&gt; import Data.List 
    Prelude Data.List&gt; let numUniques&#39; = length . nub
    Prelude Data.List&gt; :t numUniques&#39;
    numUniques&#39; :: [()] -&gt; Int

The resulting function only accepts a list of units as a parameter.

Is there a way provide type declarations in GHCi? Or is there another way to define functions like these which doesn&#39;t require type declarations?

I saw no obvious clues in the GHCi guide, and experimented with expressions like the following (to no avail):

    &gt; let numUniques&#39; = ((length . nub) :: (Eq a) =&gt; [a] -&gt; Int)
    &gt; :t numUniques&#39;
    numUniques&#39; :: [()] -&gt; Int

  [1]: http://learnyouahaskell.com/

How to provide explicit type declarations for functions when using GHCi?

I was initially surprised that Java decides to specify that `byte` is signed, with a range from `-128..127` (inclusive). I&#39;m under the impression that most 8-bit number representations are unsigned, with a range of `0..255` instead (e.g. [IPv4 in dot-decimal notation](http://en.wikipedia.org/wiki/Dot-decimal_notation)).

So has James Gosling ever been asked to explain why he decided that `byte` is signed? Has there been notable discussions/debates about this issue in the past between authoritative programming language designers and/or critics?

James Gosling&#39;s explanation of why Java&#39;s byte is signed

I am exploring the Scala language. One claim I often hear is that Scala has a _stronger_ type system than Java. By this I think what people mean is that:

  * `scalac` rejects certain buggy programs which `javac` will compile happily, only to cause a runtime error.
  * Certain invariants can be encoded in a Scala program such that the compiler won&#39;t let the programmer write code that violates the condition.

Am I right in thinking so?

Advantages of Scala&#39;s type system

I was wondering what the difference between `BigInt`, `MediumInt`, and `Int` are... it would seem obvious that they would allow for larger numbers; however, I can make an `Int(20)` or a `BigInt(20)` and that would make seem that it is not necessarily about size.

Some insight would be awesome, just kind of curious. I have been using **MySQL** for a while and trying to apply business needs when choosing types, but I never understood this aspect.

Types in MySQL: BigInt(20) vs Int(20)

I have read that Scala&#39;s type system is weakened by Java interoperability and therefore cannot perform some of the same powers as Haskell&#39;s type system.  Is this true?  Is the weakness because of type erasure, or am I wrong in every way?  Is this difference the reason that Scala has no typeclasses?


Disadvantages of Scala type system versus Haskell?

There are claims that Scala&#39;s type system is Turing complete. My questions are:

1. Is there a formal proof for this?

2. How would a simple computation look like in the Scala type system?

3. Is this of any benefit to Scala - the language? Is this making Scala more &quot;powerful&quot; in some way compared languages without a Turing complete type system?

I guess this applies to languages and type systems in general.

The type system in Scala is Turing complete. Proof? Example? Benefits?

It is well known that Haskell-style typeclasses and ML-style modules offer different mechanisms for specifying *interfaces*. They are (possibly) equivalent in power, but in practice each has their own benefits and drawbacks.

Since I&#39;m a bit of an inclusionist when it comes to language features, my question is this: What are the primary theoretical difficulties with adding ML-style modules to Haskell? I&#39;m interested in answers along the following lines:

* What existing type system features interact poorly with ML-style modules? (An example of poor interaction is GADT and functional dependencies, even though fundeps are technically equivalent to associated types!)

* What things have to be given up on the compiler end in order to compile ML-style modules?

* How do ML style modules interact with type inference?

Related reading:

* &lt;a href=&quot;http://existentialtype.wordpress.com/2011/04/16/modules-matter-most/&quot;&gt;Robert Harper’s post that provoked this question&lt;/a&gt;
* &lt;a href=&quot;http://www.reddit.com/r/haskell/comments/grq99/ml_modules_matter_most/&quot;&gt;Discussion on Haskell Reddit&lt;/a&gt;

What are the primary theoretical difficulties with adding ML-style modules to Haskell?

What is the difference when I write this?

    data Book = Book Int Int

versus

    newtype Book = Book (Int, Int) -- &quot;Book Int Int&quot; is syntactically invalid

Difference between `data` and `newtype` in Haskell

A [recent blog post on William Cook&#39;s Fusings](http://wcook.blogspot.com/) mentions:

&gt; The key point is that structures in Ensō are viewed holistically as graphs, not as individual values or traditional sums-and-products data structures.

What are the traditional sums-and-products data structures he is referring to?

Content Type	Original Author	Original Content on Stackoverflow
Question	Ming-Tang	View Question on Stackoverflow
Solution 1 - Haskell	Don Stewart	View Answer on Stackoverflow

Haskell Weird Kinds: Kind of (->) is ?? -> ? -> *

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

DDD and MVC: Difference between 'Model' and 'Entity'

Right click to select a row in a Datagridview and show a menu to delete it

Attributions