- Haskell-Cafe - Haskell.org

Haskell RPC
by Joel Reymont 30 May '06

30 May '06

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/

9 11

State Variables
by Matthew Bromberg 30 May '06

30 May '06

I've been toying with the idea of using Haskell to write a medium sized simulation of a wireless network. However I have a number of concerns as I've begun to program a bit more in Haskell. The first concern is that the simulation needs to be fast, much faster than Matlab for example, to justify the use of Haskell. Given GHCs speed improvement in recent releases, I have high hopes that this is possible. To be honest, I'd probably pick Clean here, but I've been unable to consistently link to third party DLLs with the Clean IDE. The second concern is that the simulation requires heavy use of complex valued matrices. Since I'm on windows and the only reasonably well developed matrix library doesn't run on windows I would be forced to use the FFI to bring in various BLAS and LAPACK routines to support this. I've convinced myself that this is quite possible, if somewhat tedious by virtue of the unpleasant array access syntax for mutable arrays. The third and final concern is the point of this post. How does one handle state efficiently in Haskell? I've seen the various state monads and gained a superficial enough understanding to be concerned about how useful they are, for the following reason: I would like to aggregrate a large number of state variables (possibly in the hundreds of variables) into a few data structures. These structures would not only contain basic variable types, but probably some rather large mutable arrays. So lets say I have such a structure called world and I wish to update just 1 entry. If I do w=world{entry=newentry}, the entire enormous world structure is copied to w. If I bury world in a state monad, then inside a do loop it appears that the get function extracts the entire world state and the set function writes it back into the monad after I've altered it. It still seems to me that the entire structure is copied again to achieve this. I'm not sure if this is true or not. Perhaps the compiler can pull apart the aggregation to fix this issue, but I'm not sure if such an optimization is performed. The only other thing I could think of would be to somehow create get and set functions for every variable in the aggregation, which also would be impossibly tedious. It is possible for me to structure the program so that most of the simulation parameters are set once by the user and then never changed during the rest of the program operation, although incremental state updates are a bit more efficient than this approach. To make this reasonably clean I would probably do some kind of unsafe extraction out of the IO monad to get my input variables, which would then not be changed for the rest of the simulation, although many of the matrices, themselves embedded in the IO monad would have to change incrementally as the simulation progresses. Right now I would favor the latter approach, if I stay with Haskell, but so far it's not clear to me that Haskell is 'convenient' for this kind of development, though I would like to be proven wrong. I am also looking at D or possibly LUA+C for this task, but LUA is not much faster than Matlab.

4 12

Re: [Haskell-cafe] swap a pair of integers
by David House 30 May '06

30 May '06

This was originally, and accidentally, sent to just Jenny, and not the list. On 29/05/06, Jenny678 <mestor1(a)gmx.de> wrote: > hello, > i want swap a pair of integers > for example > Main> 17 > out> 71 > Can somebody help me? When you want to do manipulation on the digits of a number like this, normally the easiest thing to do is to convert it to a string, use list manipulation functions, then convert back to an integer. For example: Prelude> (read . reverse . show) 17 71 -- -David House, dmhouse(a)gmail.com

2 1

Re: help with MPTC for type proofs?
by oleg＠pobox.com 30 May '06

30 May '06

David Roundy wrote: > class Commutable a b d c > > commute :: Commutable a b d c => > (Patch a b, Patch b c) -> (Patch a d, Patch d c) > > But for this to work properly, I'd need to guarantee that > > 1. if (Commutable a b d c) then (Commutable a d b c) > > 2. for a given three types (a b c) there exists at most one type d > such that (Commutable a b c d) The problem seems easily solvable, exactly as described. We need to take care of the two requirements separately. > {-# OPTIONS -fglasgow-exts #-} > {-# OPTIONS -fallow-undecidable-instances #-} > > module D1 where > > data Patch a b = Patch String deriving Show > > -- This is identical to what Tom Schrijvers wrote > class Commutable a b c d | > a b c -> d, -- 2. > a d c -> b -- based on 1. + 2. > > -- But how do we make sure that Commutable a d c b exists whenever > -- Commutable a b c d does? very easily: with the help of another > -- type class > instance (Commutable' a b c d, Commutable' a d c b) > => Commutable a b c d > > class Commutable' a b c d | a b c -> d > > -- The desired function > commute :: Commutable a b c d => > (Patch a b, Patch b c) -> (Patch a d, Patch d c) > commute ((Patch p1),(Patch p2)) = ((Patch p1),(Patch p2)) > > -- Testing > -- Define some patch labels > > data PL1 > data PL2 > data PL2I > data PL3 > data PL4 > > instance Commutable' PL1 PL2 PL3 PL2I > -- If the latter is commented out, there will be an error in testab below > instance Commutable' PL1 PL2I PL3 PL2 > > pa :: Patch PL1 PL2 = Patch "PA: 1->2" > pe :: Patch PL2 PL3 = Patch "PE: 2->3" > > -- Test as was in David Roundy's message > test (a,b) = do (b',a') <- return $ commute (a,b) > (b'', a'') <- return $ commute (a,b) > (a''',b''') <- return $ commute (b',a'') > return () > > testab :: IO () = test (pa,pe) However, something tells me that the above approach isn't useful. We really would like to have as many patch labels as _dynamically_ needed. Also, we probably would like to specify which patches commute dynamically, rather than statically. That is, we wish to examine the patches and only then conclude if they commute. Thus we need to program with evidence. The function commute becomes a semantic function: it really does something, at run-time. It examines the patches. If it decides the patches commute, it produces the pair of patches, marked with a unique and unforgeable type d -- along with the evidence that d is indeed determined by b, and vice versa. We need this evidence for the creative mixing of patches, as in the original test. This approach is not unlike the one described half a year ago, in response to a similar query: http://www.haskell.org/pipermail/haskell-cafe/2005-December/012703.html I still don't know if the were some problems with that approach. Anyway, here's the complete code: > {-# OPTIONS -fglasgow-exts #-} > > module D2 where > > data Patch a b = Patch String deriving Show > > -- Define the commutation pair > data CP a b c = forall d. CP (Patch a d) (Patch d c) (EQP b d) > > data EQP b d = EQP -- Hide the constructor > > -- The following creates the proof > -- Assume patches commute if their bodies are the same > commute :: Patch a b -> Patch b c -> CP a b c > commute (Patch p1) (Patch p2) | p1 == p2 = CP (Patch p1) (Patch p2) EQP > > -- Testing > -- Define some patch labels > > data PL1 > data PL2 > data PL3 > data PL4 > > pa :: Patch PL1 PL2 = Patch "PA: 1->2" > pe :: Patch PL2 PL3 = Patch "PA: 1->2" > > -- coercion functions, using the evidence > a1 :: Patch a d -> EQP b d -> Patch a b > a1 (Patch p) EQP = Patch p > a2 :: Patch d c -> EQP b d -> Patch b c > a2 (Patch p) EQP = Patch p > > test a b = do CP b' a' e' <- return $ commute a b > CP b'' a'' e'' <- return $ commute a b > CP a''' b''' e''' <- return $ commute (a1 b' e') (a2 a'' e'') > return () > > testab :: IO () = test pa pe

4 5

Re: [Haskell] (.) . (.)
by Brian Hulley 30 May '06

30 May '06

[moved to cafe] Dominic Steinitz wrote: > Taral wrote: >> On 5/28/06, Dominic Steinitz <dominic.steinitz(a)blueyonder.co.uk> >> wrote: >>> Is this defined in some library? Thanks, Dominic. >> >> Don't think so. I use: >> >> \a b -> f (g a b) >> > Taral, > > Thanks. What prompted this question is that I find myself writing > things like: > > foo = ((.).(.)) concat intersperse Hi Dominic - I hope it's ok for me to ask this question and I'm absolutely burning with curiosity to find out the answer... How did you know to write ((.).(.)) instead of (\f g a b -> f (g a b)) ? Although the correctness of the above translation has been proved, it seems extremely non-obvious to me that to compose a function with another function which takes two arguments you should use the compose function to compose the compose function with itself... Is this kind of composition common in some branch of Lambda calculus? Is it something that I might in time be able to see directly without having to go through a proof? Does anyone else "see" the above translation intuitively and is there a way to imagine it? Thanks, Brian. -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com

5 8

swap a pair of integers
by Jenny678 30 May '06

30 May '06

hello, i want swap a pair of integers for example Main> 17 out> 71 Can somebody help me? -- View this message in context: http://www.nabble.com/swap+a+pair+of+integers-t1700880.html#a4615989 Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

1 0

How to print the " character without the backslash
by Nuno Santos 30 May '06

30 May '06

Hi, I have this basic question of how to print the character " without the backslash. I'm trying to print html code, so i need " a lot. giveHtml (Leaf (a,(b,c))) = "<frame src=\"\" name=\"" ++ [a] ++ "\" scrolling=\"No\" noresize=\"noresize\" id=\"" ++ [a] ++ "\" title=\"" ++ [a] ++ "\" />" Can anybody give me a light here? Many thx, Nuno Santos

3 2

OT - lamba calculus definition - alpha reduction
by Dušan Kolář 29 May '06

29 May '06

Hello all, I'm asking in place of several my colleagues and myself of course. The question is almost off topic. It is from lambda calculus definition, in particular, definition of alpha reduction (and others as well). Alpha reduction definition: a lambda expression (\v.e) can be transformed (reduced) to (\v'.e[v'/v]) if the substitution e[v'/v] is valid. Beta reduction definition: a lambda expression (e1 e2) can be reduced to the expression e[e2/v] if e1 is of the form (\v.e) and if the substitution e[e2/v] is valid. Eta reduction definition: a lambda expression e can be reduced to a lambda expression (\v.e v) if v is not free in e. OK. If we have these two expressions: 1) (\x.x b x) 2) (\x.x c x) The question is, are they equal? (They are not identical, of course.) For answer "no", there is a strong argument - there is no reduction sequence that can make these identical. On the other hand, their "meaning" expresses the same operation. Well, what is the answer? I will be lucky with any link to WWW resource or your opinion. Nevertheless, the more formal and precise your answer will be the more I will be lucky. ;-) Thx and regards Dusan

4 5

(no subject)
by Christophe Poucet 29 May '06

29 May '06

Dear, I will try to explain what I'm trying to achieve, below you can find the code demonstrating where I'm at currently, and where I would like to ideally get, as well as the current compilation error. Basically I'm working on a minilanguage that I would like to simulate. This language is based on a core concept which can in the example below is "Foo". Now there is a 'primitive' instance of Foo that is the list. What I now want to do is make FooF an instance as well. FooF being a record based on a map that contains some other instances of Foo by name as well as code that will use this lookup table. For instance (this is not definite syntax): my pseudoproglanguage: A = [1..10] (aka refer to the 'primitive' instance of Foo) B = [1..10] (aka refer to the 'primitive' instance of Foo) bar C = if dum B then bar A else bar B dum C = dum A && dum B I realize I need existentials for this, but I'm afraid that my type-fu is lacking in this area. Perhaps one of you could point me in the right direction. With regards, Christophe ------------------------------------------------------------------------------------------------------------ {-# OPTIONS_GHC -fglasgow-exts #-} module FooBar where import qualified Data.Map as M class Foo f b | f -> b where foo :: f a -> b bar :: f a -> b -> b dum :: f a -> b -> Bool instance Foo [] Int where foo c = 0 bar c i = i+1 dum c i = (length c == i) data F b a = forall f. Foo f b => F (f a) instance Foo (F b) b where foo (F c) = F . foo $ c bar (F c) i = bar c i dum (F c) i = dum c i data FooF b a = FooF { cols :: M.Map String (F b a), barC :: M.Map String (F b a) -> b -> b, dumC :: M.Map String (F b a) -> b -> Bool } instance Foo (FooF b) b where foo c = fmap (foo) c bar c i = barC c (cols c) i dum c i = dumC c (cols c) i makeFooF cols barC dumC = FooF {cols = cols, barC = barC, dumC = dumC} -- Example: -- makeFooF -- [("A", [1..10]), ("B", [1..8])] -- (\t -> if dum (M.lookup "A" t) -- then bar (M.lookup "B" t) -- else bar (M.lookup "A" t) -- (\t -> dum (M.lookup "A" t) && dum (M.lookup "B" t) -- Ideally this system would also allow to make some FooF that is based on another FooF, hence the reason for existentials -- FooBar.hs:19:16: -- Couldn't match the rigid variable `b' against `F b1 a' -- `b' is bound by the instance declaration at FooBar.hs:18:0 -- Expected type: b -- Inferred type: F b1 a -- In the expression: (F . foo) $ c -- In the definition of `foo': foo (F c) = (F . foo) $ c -- -- FooBar.hs:31:12: -- Couldn't match the rigid variable `b' against `f b1' -- `b' is bound by the instance declaration at FooBar.hs:30:0 -- Expected type: b -- Inferred type: f b1 -- In the application `fmap (foo) c' -- In the definition of `foo': foo c = fmap (foo) c -- Failed, modules loaded: none. -- ----------------------------------------- -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

1 0

Re: [Haskell] (.) . (.)
by Brian Hulley 29 May '06

29 May '06

[moved to cafe] Robert Dockins wrote: > On Sunday 28 May 2006 05:02 pm, Brian Hulley wrote: >> I see my error was that I was reversing the args in eta expansion, >> so the correct derivation is: > > FYI, eta-expansions isn't valid in Haskell. Its safe in this > derivation, but it isn't always. Am I right in thinking that this is because of _|_ ? In any case I suppose I should have instead just replaced the function with it's definition like you (view Lambda Shell) and Christophe did. Also, is your Lambda Shell publicly available? (I had a quick look on the wiki in the Theorem provers section but couldn't find a link.) Thanks, Brian.

2 2