On 5/25/06, Joel Reymont wrote:

This is an example from my test harness:

(define-test remote-basic (def-remote-class remote (server) ()) (def-remote-method sum :sync ((self remote) (a fixnum) (b integer)) (declare (ignorable ip port)) (+ a b seqnum)) (let* ((port (+ 1000 (random 50000))) (server (make-instance 'remote :port port)) (client (make-instance 'remote-proxy :host (host-address) :port port))) (assert-equal '(6) (sum client 1 2 :seqnum 3)) (stop server) (stop client) ))

I won't comment on the difference between haskell and lisp (both languages I respect), but I will say that you should add a macro or high order function (depneding on lisp vs. haskell) that is something like "(with-client (c args-list) body)", that way you can simplify the creation/cleanup of clients. Same idea as with-open-file. You can do the same with server. As for your actual question, there is a deriving(Read), but I don't remember what extensions are needed. Jason

Given that we have no easy way to serialize thunks, the whole RPC approach just seems wrong for Haskell. RPC in general is pretty old school. REST seems to have worked better in practice (e.g. HTTP GET/POST!). For a general description of REST see http://webservices.xml.com/pub/a/ws/2002/02/06/rest.html For a summary of the REST vs RPC issue see e.g. http://www.tbray.org/ongoing/When/200x/2003/05/12/SoapAgain Note that Amazon exposed both sorts of interfaces and found the REST style interface much more popular! That being said, I am actually looking or a good Haskell SOAP client lib to talk to paypal so YMMV. -Alex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com On Thu, 25 May 2006, Joel Reymont wrote:

Folks,

I'm curious about how the following bit of Lisp code would translate to Haskell. This is my implementation of Lisp RPC and it basically sends strings around, printed "readably" and read on the other end by the Lisp reader. If I have a list '(1 2) it prints as "(1 2)" and becomes '(1 2) again when read on the other end.

I'm wrote a couple of macros to make the job of defining the RPC easier. def-remote-class defines the main (server) class as well as the client (proxy) class.

def-remote-method creates the server method as well as a proxy method that sends data over and possibly waits for results and returns them (depending on the :async or :sync qualifier). My Lisp RPC code runs on top of UDP, looks good and works well. I have a soft spot for Haskell in my heart, though, so I wonder how I would go about implementing the same architecture in Haskell.

This is an example from my test harness:

(define-test remote-basic (def-remote-class remote (server) ()) (def-remote-method sum :sync ((self remote) (a fixnum) (b integer)) (declare (ignorable ip port)) (+ a b seqnum)) (let* ((port (+ 1000 (random 50000))) (server (make-instance 'remote :port port)) (client (make-instance 'remote-proxy :host (host-address) :port port))) (assert-equal '(6) (sum client 1 2 :seqnum 3)) (stop server) (stop client) ))

I think I can send Haskell code over the wire to be read on the other side just like I do with Lisp. The part that baffles me is being able to provide an interface that lets one easily define remote classes and methods.

I totally hate Template Haskell because I find it incomprehensible and I'm not going to compare it to Lisp macros. Is there a way to do it without TH?

Also, it seems to me that the only way to deal with variable numbers of differently typed arguments is to use the HList approach which is quite heavy machinery, IMO.

Any suggestions?

Thanks, Joel

P.S. The Haskell Cafe has been a bit quiet lately so I do mean to stir it up some. I think this example shows the advantage of dynamically-typed languages. I'm also genuinely interested in possible Haskell solutions.

-- http://wagerlabs.com/

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

hi 2006/5/25, Joel Reymont :

[snip] Also, it seems to me that the only way to deal with variable numbers of differently typed arguments is to use the HList approach which is quite heavy machinery, IMO.

(i ve made a quick read of previous reply .. think there is not my answer :) the usual way to deal with that is just http://www.haskell.org/hawiki/ExistentialTypes. To put it simply : u encapsulate each different data type in one "unifying" wrapping type. It works as long as each wrapped type belongs to the same (haskell) class. I think that if you add a String or something to identify the wrapped data, you can manage the data part of you problem (but i dont know for moving functions). Cheers, mt