The solution is to not use higher order functions like &#39;alter&#39;. The benefits of acid-state (ACID guarantees, running code remotely, etc) comes at the cost of only using serialisable data. This
restriction is unlikely to ever be lifted.


Usually this is a not a big problem; Just specialise your code. If this doesn&#39;t cut it, maybe you want to keep your state in an MVar.

I&#39;m perplexed by the behavior of the following CSS, also illustrated [in this fiddle](http://jsfiddle.net/Y7Jta/3/).

    &lt;style type=&quot;text/css&quot;&gt;
    p {
        font-size: 14px;
    }
    
    .percentage {
        line-height: 150%;
    }
    
    .em-and-a-half {
        line-height: 1.5em;
    }
    
    .decimal {
        line-height: 1.5;
    }
    
    .smaller {
        font-size:50%;
    }
    
    .caption {
        font-weight: bolder;
        font-size: 80%;
    }
    
    &lt;/style&gt;

    &lt;p class=&quot;caption&quot;&gt;default line spacing&lt;/p&gt;

    &lt;p&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    &lt;p&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;smaller&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    
    &lt;p class=&quot;caption&quot;&gt;line-height: 150%&lt;/p&gt;
    
    &lt;p class=&quot;percentage&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    &lt;p class=&quot;percentage&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;smaller&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    
    &lt;p class=&quot;caption&quot;&gt;line-height: 1.5em&lt;/p&gt;
    
    &lt;p class=&quot;em-and-a-half&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    &lt;p class=&quot;em-and-a-half&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;smaller&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    
    &lt;p class=&quot;caption&quot;&gt;line-height: 1.5&lt;/p&gt;
    
    &lt;p class=&quot;decimal&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;
    
    &lt;p class=&quot;decimal&quot;&gt;This tutorial provides a brief introduction to the
    programming &lt;span class=&quot;smaller&quot;&gt;language&lt;/span&gt; by using one of its picture-drawing
    libraries. This tutorial provides a brief introduction to the programming language. This tutorial provides a brief introduction to the programming language.&lt;/p&gt;

The first two paragraphs have default line spacing. The second paragraph has one word that is smaller. But it doesn&#39;t affect the line spacing in that paragraph. Not that it should, but then —

The next two paragraphs have `line-height: 150%`. Again, the second paragraph has one word that&#39;s smaller. But this time, for reasons unclear, the smaller font creates extra space between the first two lines (at least in Safari, Chrome, Firefox and Explorer). This is the original problem in my CSS that I was trying to fix. (I speculate that it has something to do with the browser shrinking the word and then shifting it downward vertically to realign the baselines.)

The next two paragraphs have `line-height: 1.5em`. My understanding is that `1.5em` is the same as `150%`. And indeed, the behavior is the same: extra space between the first two lines of the second paragraph.

**But here&#39;s where it gets weird**: the next two paragraphs have `line-height: 1.5` — no unit specified. This time, the extra-space problem disappears.

[&lt;img src=&quot;http://i.stack.imgur.com/6bJu2.png&quot; width=&quot;124&quot; height=&quot;152&quot;&gt;](http://i.stack.imgur.com/6bJu2.png)

In sum, CSS seems to be giving consistent line-spacing results when the line heights of the parent &amp; child are different (through inheritance of the unitless value) but inconsistent results when the line heights of the parent &amp; child are the same. 

Thus my questions: 

 1. I know there&#39;s an intentional semantic difference [in the CSS spec](http://www.w3.org/TR/2011/PR-CSS2-20110412/visudet.html#propdef-line-height) between `1.5` and `150%` or its synonym, `1.5em`. (Namely: a unitless value is passed to the child element and its line height is calculated using the child&#39;s font size, whereas a percentage or em value will cause a line height to be calculated for the parent, and then that calculated value is passed to the child.) But how does this account for the difference in behavior seen here? Where is the extra space coming from? If it&#39;s a consequence of some CSS positioning rule, then what is that rule?

 2. Or, if these examples should all render the same way, then which one is implemented incorrectly? (Note on Q2: The fact that the rendering quirk happens the same way across different browsers strongly suggests that none of them are implemented incorrectly, which will take you back to question (1).)

 3. &lt;strike&gt;In practical terms, is there a downside to switching to unitless measurements like `1.5` for `line-height`?&lt;/strike&gt; (Answer: no)




Why does unitless line-height behave differently from percentage or em in this example?

I am trying to run a shell command from within awk for each line of a file, and the shell command needs one input argument. I tried to use `system()`, but it didn&#39;t recognize the input argument. 

Each line of this file is an address of a file, and I want to run a command to process that file. So, for a simple example I want to use &#39;wc&#39; command for each line and pass `$1 `to wc. 

    awk &#39;{system(&quot;wc $1&quot;)}&#39; myfile

How can I pass variables from awk to a shell command?

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 have a moderately sized application that uses <code>Data.Acid</code> for persistence and I've encountered a situation where I need to update the implementation of one of my <code>Update</code> events for the next version of the server. I.e. I have something like
<pre><code class="hljs language-csharp">myUpdate :: Update MyState ()
myUpdate = &#x3C;some outdated implementation>
</code></pre>
Now, obviously I can'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:
<ol>
<li>
Stop the server. Run <code>createCheckpoint</code> for my <code>AcidState</code>. Update the <code>Event</code> implementation and then restart the server. Since we load from a fresh snapshot, the changed <code>Update</code> should never trigger for the old events.
</li>
<li>
Create a a new <code>Update</code> with a new name (like <code>myUpdate_v2</code>) and update my server logic to only use <code>myUpdate_v2</code> everywhere instead of the original <code>myUpdate</code>.
</li>
</ol>
I think both options have their merits. (1) is nicer since I don'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 <code>myUpdate</code> from my module's exports so I can be sure I don'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.

Say I have the following functions:

    infixr 0 &lt;|

    {-# INLINE (&lt;|) #-}
    (&lt;|) :: (a -&gt; b) -&gt; a -&gt; b
    f &lt;| x = f x

    foo :: a -&gt; (forall b. b -&gt; b) -&gt; a
    foo x f = f x

The following does not type check:

    ghci&gt; foo 3 &lt;| id

    Couldn&#39;t match expected type `forall b. b -&gt; b&#39;
                with actual type `a0 -&gt; a0&#39;
    In the second argument of `(&lt;|)&#39;, namely `id&#39;
    In the expression: f 3 &lt;| id
    In an equation for `it&#39;: it = f 3 &lt;| id

However, `foo 3 $ id` _does_.

The definition of (&lt;|) is (as far as I know) identical to the definition of ($). I pretty much ripped out the definition from the base library sources, and changed every instance of ($) to (&lt;|). Compiler magic?

Haskell&#39;s ($) is a magic operator?

I&#39;m confused about how to choose between `data family` and `type family`. The wiki page on [TypeFamilies][1] goes into a lot of detail. Occasionally it informally refers to Haskell&#39;s `data family` as a &quot;type family&quot; in prose, but of course there is also `type family` in Haskell.

There is a simple example that shows where two versions of code are shown, differing only on whether a `data family` or a `type family` is being declared:

    -- BAD: f is too ambiguous, due to non-injectivity
    -- type family F a
     
    -- OK
    data family F a 

    f :: F a -&gt; F a
    f = undefined
     
    g :: F Int -&gt; F Int
    g x = f x


`type` and `data` here have the same meaning, but the `type family` version fails to  type-check, while the `data family` version is fine, because `data family` &quot;creates new types and are therefore injective&quot; (says the wiki page).


My takeaway from all of this is &quot;try `data family` for simple cases, and, if it isn&#39;t powerful enough, then try `type family`&quot;. Which is fine, but I&#39;d like to understand it better. Is there a Venn diagram or a decision tree I can follow to distinguish when to use which?

  [1]:http://www.haskell.org/haskellwiki/GHC/Type_families#Injectivity.2C_type_inference.2C_and_ambiguity

&#39;type family&#39; vs &#39;data family&#39;, in brief?

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

I&#39;ve been doing dev in F# for a while and I like it.  However one buzzword I know doesn&#39;t exist in F# is higher-kinded types.  I&#39;ve read material on higher-kinded types, and I think I understand their definition.  I&#39;m just not sure why they&#39;re useful.  Can someone provide some examples of what higher-kinded types make easy in Scala or Haskell, that require workarounds in F#?  Also for these examples, what would the workarounds be without higher-kinded types (or vice-versa in F#)?  Maybe I&#39;m just so used to working around it that I don&#39;t notice the absence of that feature.

(I think) I get that instead of `myList |&gt; List.map f` or `myList |&gt; Seq.map f |&gt; Seq.toList` higher kinded types allow you to simply write `myList |&gt; map f` and it&#39;ll return a `List`.  That&#39;s great (assuming it&#39;s correct), but seems kind of petty?  (And couldn&#39;t it be done simply by allowing function overloading?)  I usually convert to `Seq` anyway and then I can convert to whatever I want afterwards.  Again, maybe I&#39;m just too used to working around it. But is there any example where higher-kinded types *really* saves you either in keystrokes or in type safety?

When are higher kinded types useful?

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

Content Type	Original Author	Original Content on Stackoverflow
Question	shang	View Question on Stackoverflow
Solution 1 - Haskell	Neeraj Prajapati	View Answer on Stackoverflow

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

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

How can I pass variables from awk to a shell command?

Why does unitless line-height behave differently from percentage or em in this example?

Attributions