~ Separate method implementation.

This will break everything for now.

1 files changed, 22 insertions, 25 deletions

diff --git a/src/Remote/KRPC/Method.hs b/src/Remote/KRPC/Method.hs
index f4b0bb9a..3c757d07 100644
--- a/src/Remote/KRPC/Method.hs
+++ b/src/Remote/KRPC/Method.hs
@@ -1,12 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Remote.KRPC.Method
-       ( Method(methodName, methodParams, methodVals, methodBody)
+       ( Method(methodName, methodParams, methodVals)
 
          -- * Construction
        , method
 
          -- * Predefined methods
-       , idM, composeM, concatM
+       , idM, composeM
        ) where
 
 import Prelude hiding ((.), id)
@@ -15,6 +15,8 @@ import Control.Monad
 
 import Remote.KRPC.Protocol
 
+
+
 -- | The
 --
 --   * argument: type of method parameter
@@ -23,30 +25,35 @@ import Remote.KRPC.Protocol
 --
 --   * result: type of return value of the method.
 --
-data Method remote param result = Method {
+data Method param result = Method {
     -- | Name used in query and
     methodName   :: [MethodName]
 
-    -- | Description of each method parameter in right to left order.
+    -- | Description of each parameter in /right to left/ order.
   , methodParams :: [ParamName]
 
-    -- | Description of each method return value in right to left order.
+    -- | Description of each return value in /right to left/ order.
   , methodVals   :: [ValName]
-
-    -- | Description of method body.
-  , methodBody   :: param -> remote result
   }
 
-instance Monad remote => Category (Method remote) where
+instance Category Method where
+  {-# SPECIALIZE instance Category Method #-}
   id  = idM
+  {-# INLINE id #-}
+
   (.) = composeM
+  {-# INLINE (.) #-}
+
+
+-- TODO ppMethod
 
 -- | Remote identity function. Could be used for echo servers for example.
 --
 --   idM = method "id" ["x"] ["y"] return
 --
-idM :: Monad m => Method m a a
-idM = method "id" ["x"] ["y"] return
+idM :: Method a a
+idM = method "id" ["x"] ["y"]
+{-# INLINE idM #-}
 
 -- | Pipelining of two or more methods.
 --
@@ -54,23 +61,13 @@ idM = method "id" ["x"] ["y"] return
 --   KRPC, so both server and client should use this implementation,
 --   otherwise you more likely get the 'ProtocolError'.
 --
-composeM :: Monad m => Method m b c -> Method m a b -> Method m a c
+composeM :: Method b c -> Method a b -> Method a c
 composeM g h = Method (methodName g ++ methodName h)
                       (methodParams h)
                       (methodVals g)
-                      (methodBody h >=> methodBody g)
-
--- | Concat list of list. Could be used for performance tests.
---
---   concatM = method "concat" ["xxs"] ["xs"] $ return . Prelude.concat
---
-concatM :: Monad m => Method m [[a]] [a]
-concatM = method "concat" ["xxs"] ["xs"] $ return . Prelude.concat
+{-# INLINE composeM #-}
 
 
-method :: MethodName
-       -> [ParamName]
-       -> [ValName]
-       -> (param -> remote result)
-       -> Method remote param result
+method :: MethodName -> [ParamName] -> [ValName] -> Method param result
 method name = Method [name]
+{-# INLINE method #-}
\ No newline at end of file