To quote section 6.4.2 from the Haskell report:

The `quot`, `rem`, `div`, and `mod` class methods satisfy these laws if y is non-zero:

    (x `quot` y)*y + (x `rem` y) == x  
    (x `div`  y)*y + (x `mod` y) == x

`quot` is integer division truncated toward zero, while the result of `div` is truncated toward negative infinity.

The `div` function is often the more natural one to use, whereas the `quot` function corresponds to the machine instruction on modern machines, so it&#39;s somewhat more efficient.

The two behave differently when dealing with negative numbers. Consider:

    Hugs&gt; (-20) `divMod` 3
    (-7,1)
    Hugs&gt; (-20) `quotRem` 3
    (-6,-2)

Here, `-7 * 3 + 1 = -20` and `-6 * 3 + (-2) = -20`, but the two ways give you different answers.

Also, see here: http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html

The definition for `quot` is &quot;integer division truncated toward zero&quot;, whereas the definition for `div` is &quot;integer division truncated toward negative infinity&quot;.

I am sending push notifications from php job application to iphone. I am sending push notifications regarding new jobs. Is this possible that when user click on the view of push notification pop up , then user redirect to the particular job in the device.

I mean I wanted to know can I send any custom data with push notification like jobId,something else....so that Iphone end Can retrieve and show the particular job ?

Thanks.

Apple Push Notification with Sending Custom Data

I have an OO hierarchy with docstrings that take as much maintenance as the code itself. E.g.,

    class Swallow(object):
        def airspeed(self):
            &quot;&quot;&quot;Returns the airspeed (unladen)&quot;&quot;&quot;
            raise NotImplementedError

    class AfricanSwallow(Swallow):
        def airspeed(self):
            # whatever

Now, the problem is that `AfricanSwallow.airspeed` does not inherit the superclass method&#39;s docstring. I know I can keep the docstring using the template method pattern, i.e.

    class Swallow(object):
        def airspeed(self):
            &quot;&quot;&quot;Returns the airspeed (unladen)&quot;&quot;&quot;
            return self._ask_arthur()

and implementing `_ask_arthur` in each subclass. However, I was wondering whether there&#39;s another way to have docstrings be inherited, perhaps some decorator that I hadn&#39;t discovered yet?

Inheriting methods&#39; docstrings in Python

Type class Integral has two operations `quot` and `div`, yet in the Haskell 2010 Language Report it is not specified what they&#39;re supposed to do. Assuming that `div` is integral division, what does `quot` differently, or what is the purpose of `quot`? When do you use one, and when the other?

Integral operators quot vs. div

<p>Type class Integral has two operations <code>quot</code> and <code>div</code>, yet in the Haskell 2010 Language Report it is not specified what they're supposed to do. Assuming that <code>div</code> is integral division, what does <code>quot</code> differently, or what is the purpose of <code>quot</code>? When do you use one, and when the other?</p>


&gt; **Possible Duplicate:**  
&gt; [Java&amp;#39;s Interface and Haskell&amp;#39;s type class: differences and similarities?](https://stackoverflow.com/questions/6948166/javas-interface-and-haskells-type-class-differences-and-similarities)  

&lt;!-- End of automatically inserted text --&gt;

When I started learning Haskell, I was told that type classes are different and more powerful than interfaces.

One year later, I&#39;ve used interfaces and type classes extensively and I&#39;ve yet to see an example or explanation of how they are different. It&#39;s either not a revelation that comes naturally, or I&#39;ve missed something obvious, or there is in actual fact no real difference.

Searching the Internet hasn&#39;t turned up anything substantial. So SO, do you have the answer?


Difference between OOP interfaces and FP type classes

Every time someone promises to &quot;explain monads&quot;, my interest is piqued, only to be replaced by frustration when the alleged &quot;explanation&quot; is a long list of examples terminated by some off-hand remark that the &quot;mathematical theory&quot; behind the &quot;esoteric ideas&quot; is &quot;too complicated to explain at this point&quot;.

Now I&#39;m asking for the opposite. I have a solid grasp on category theory and I&#39;m not afraid of diagram chasing, Yoneda&#39;s lemma or derived functors (and indeed on *monads* and adjunctions in the categorical sense).

Could someone give me a *clear and concise* definition of what a monad is in functional programming? The fewer examples the better: sometimes one clear concept says more than a hundred timid examples. Haskell would do nicely as a language for demonstration though I&#39;m not picky.

What is a monad in FP, in categorical terms?

I&#39;m trying to figure out how to properly use the [OpenSSL.Session][1] API in a concurrent context

E.g. assume I want to implement a `stunnel-style ssl-wrapper`, I&#39;d expect to have the following basic skeleton structure, which implements a naive `full-duplex tcp-port-forwarder:`

    runProxy :: PortID -&gt; AddrInfo -&gt; IO ()
    runProxy localPort@(PortNumber lpn) serverAddrInfo = do
      listener &lt;- listenOn localPort

      forever $ do
        (sClient, clientAddr) &lt;- accept listener

        let finalize sServer = do
                sClose sServer
                sClose sClient

        forkIO $ do
            tidToServer &lt;- myThreadId
            bracket (connectToServer serverAddrInfo) finalize $ \sServer -&gt; do
                -- execute one &#39;copySocket&#39; thread for each data direction
                -- and make sure that if one direction dies, the other gets
                -- pulled down as well
                bracket (forkIO (copySocket sServer sClient
                                 `finally` killThread tidToServer))
                        (killThread) $ \_ -&gt; do
                    copySocket sClient sServer -- &quot;controlling&quot; thread

     where
      -- |Copy data from source to dest until EOF occurs on source
      -- Copying may also be aborted due to exceptions
      copySocket :: Socket -&gt; Socket -&gt; IO ()
      copySocket src dst = go
       where
        go = do
            buf &lt;- B.recv src 4096
            unless (B.null buf) $ do
                B.sendAll dst buf
                go

      -- |Create connection to given AddrInfo target and return socket
      connectToServer saddr = do
        sServer &lt;- socket (addrFamily saddr) Stream defaultProtocol
        connect sServer (addrAddress saddr)
        return sServer


How do I transform the above skeleton into a `full-duplex ssl-wrapping tcp-forwarding proxy`? Where are the dangers W.R.T to concurrent/parallel execution (in the context of the above use-case) of the function calls provided by the HsOpenSSL API?

PS: I&#39;m still struggling to fully comprehend how to make the code robust w.r.t. to exceptions and resource-leaks. So, albeit not being the primary focus of this question, if you notice something bad in the code above, please leave a comment.


  [1]: http://hackage.haskell.org/packages/archive/HsOpenSSL/0.10.3.1/doc/html/OpenSSL-Session.html

Proper use of the HsOpenSSL API to implement a TLS Server

I saw this snippet at [the devlog of omegagb][1]:

    data ExecutionAST result where
      Return :: result -&gt; ExecutionAST result
      Bind :: (ExecutionAST oldres) -&gt; (oldres -&gt; ExecutionAST result) -&gt;
              ExecutionAST result
      WriteRegister :: M_Register -&gt; Word8 -&gt; ExecutionAST ()
      ReadRegister :: M_Register -&gt; ExecutionAST Word8
      WriteRegister2 :: M_Register2 -&gt; Word16 -&gt; ExecutionAST ()
      ReadRegister2 :: M_Register2 -&gt; ExecutionAST Word16
      WriteMemory :: Word16 -&gt; Word8 -&gt; ExecutionAST ()
      ReadMemory :: Word16 -&gt; ExecutionAST Word8



What does the `data ... where` mean? I thought the keyword `data` is used to define a new type.

  [1]: http://www.mutantlemon.com/omegagb/devlog/


What does data ... where mean in Haskell?

In the following code, the last phrase I can put an `in` in front. Will it change anything? 

Another question: If I decide to put `in` in front of the last phrase, do I need to indent it? 

I tried without indenting and hugs complains 

&gt; Last generator in do {...} must be an expression

    import Data.Char
    groupsOf _ [] = []
    groupsOf n xs = 
        take n xs : groupsOf n ( tail xs )
 
    problem_8 x = maximum . map product . groupsOf 5 $ x
    main = do t &lt;- readFile &quot;p8.log&quot; 
              let digits = map digitToInt $concat $ lines t
              print $ problem_8 digits

---

### Edit

Ok, so people don&#39;t seem to understand what I&#39;m saying. Let me rephrase:
are the following two the same, given the context above?

1.

    let digits = map digitToInt $concat $ lines t
    print $ problem_8 digits

2.

    let digits = map digitToInt $concat $ lines t
    in print $ problem_8 digits

Another question concerning the scope of bindings declared in `let`: I read [here][1] that:

&gt; `where` Clauses.

Sometimes it is convenient to scope bindings over several guarded equations, which requires a where clause: 

    f x y  |  y&gt;z           =  ...
           |  y==z          =  ...
           |  y&lt;z           =  ...
         where z = x*x

Note that this cannot be done with a let expression, which only scopes over the expression **which it encloses**.

My question: so, the variable digits shouldn&#39;t be visible to the last print phrase. Do I miss something here?


  [1]: http://www.haskell.org/tutorial/patterns.html


Content Type	Original Author	Original Content on Stackoverflow
Question	Ingo	View Question on Stackoverflow
Solution 1 - Haskell	augustss	View Answer on Stackoverflow
Solution 2 - Haskell	Stuart Golodetz	View Answer on Stackoverflow

Integral operators quot vs. div

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Inheriting methods' docstrings in Python

Apple Push Notification with Sending Custom Data

Attributions