Re: [Haskell-beginners] grouping functions together

9 Jun 2015

      I used typeclasses because I want to have a "default version" of the run 
function.

I want that function to be able to call (specialized versions) of the 
other functions in the group. This is the only way *I know* to "factor 
out" common code in Haskell while still allowing the "factored out" code 
to call specialized versions of the other functions. In my view, this is 
very similar to inheritance and specialization is Object-Oriented 
Programming. Is there another way to do this?

I don't see how I could do this with a record. If the run function were 
mostly the same for all types except for calls to specialized versions 
of the others. I think I would have to write a completely separate 
version of run for each instance. The example below shows what I mean.

Also, my apologies, but my code was wrong. I now realize it did not 
capture what I need. I don't need the functions to be polymorphic for 
all types within a single instance. Within a single instance, I just 
need them to work for a few specific types. So, here's a better version 
(my current one):

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}

import Control.Monad

class Reliable m s where

     type Req s :: *     -- the type for requests
     type Atp s :: *     -- the type for attempts
     type Ack s :: *     -- the type for acknowledgments
     type Res s :: *     -- the type for results (Success)
     type Fai s :: *     -- the type for failures

     getRequests :: Monad m => s                   -> m [Req s]
     mkAttempt   :: Monad m => s -> Req s          -> m (Maybe (Atp s))
     action      :: Monad m => s -> Atp s          -> m (Maybe (Ack s))
     getAcks     :: Monad m => s ->[Atp s]         -> m [Ack s]
     mkResult    :: Monad m => s -> Req s -> Ack s -> m (Either (Fai s) 
(Res s))
     run         :: Monad m => s -> Req s          -> m (Res s)

data RemoteCall = RemoteCall

instance Reliable IO RemoteCall where

     type Req RemoteCall = Int
     type Atp RemoteCall = String
     type Ack RemoteCall = Bool
     type Res RemoteCall = String
     type Fai RemoteCall = Int

     getRequests = undefined  -- these can be specialized for each instance
     mkAttempt   = undefined
     action      = undefined
     getAcks     = undefined
     mkResult    = undefined

     run s req   = do        -- dummy version
                     mAtp <- mkAttempt s req
                     mAck <- action s (fromJust mAtp)
                     eRes <- mkResult s req (fromJust mAck)
                     return $ case eRes of
                         Left  f -> error "failure"
                         Right s -> s

I don't know how I would write the 'run' function above only once if I 
were using records. It seems I would have to duplicate code, no?

Thank you!

Dimitri

On 08/06/15 16:36, Rein Henrichs wrote:
...
This seems like a case where you only really need a record, not a 
typeclass.
On Mon, Jun 8, 2015 at 2:47 PM Dimitri DeFigueiredo 
mailto:defigueiredo@ucdavis.edu> wrote:
Hello!
I am trying to tie together a group of functions that turn an
    unreliable
    remote network call into a reliable one. For each different network
    request I make, a specific group of these functions should always work
    together, but their type signatures are quite different. My first
    thought was to put them all in a typeclass:
import Control.Monad
class Reliable1 m req attempt ack failure result where
         getRequests1 :: Monad m =>               m [req]
         mkAttempt1   :: Monad m => req        -> m (Maybe attempt)
         action1      :: Monad m => attempt    -> m (Maybe ack)
         getAcks1     :: Monad m => [attempt]  -> m [ack]
         mkResult1    :: Monad m => req -> ack -> m (Either failure
    result)
         run1         :: Monad m => req        -> m result
That doesn't work because not all functions use all parameters. For
    example, getAcks1 has no idea of what the final 'result' type
    parameter
    is. This lead me to my second attempt. Defining a 'service' type with
    the sole purpose of tying them all together. Here's my current
    attempt:
{-# LANGUAGE MultiParamTypeClasses #-}
import Control.Monad
class Reliable m service where
         getReqs     :: Monad m => service ->  m [req]
         mkAttempt   :: Monad m => service -> req -> m (Maybe attempt)
         action      :: Monad m => service -> attempt -> m (Maybe ack)
         getAcks     :: Monad m => service -> [attempt] -> m [ack]
         mkResult    :: Monad m => service -> req -> ack -> m (Either
    failure result)
         run         :: Monad m => service -> req -> m result
data RemoteCall = RemoteCall
instance Reliable IO RemoteCall where
         getReqs     = undefined
         mkAttempt   = undefined
         action      = undefined
         getAcks     = undefined
         mkResult    = undefined
         run         = undefined
This works, but I have to explicitly pass the 'service' argument in
    every call.
    Can I avoid passing this parameter every time?
    Question, is there a better way to do this?
    I wanted to have a wrapper to make my remote calls reliable.
Thanks,
Dimitri
_______________________________________________
    Beginners mailing list
    Beginners@haskell.org mailto:Beginners@haskell.org
    http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners