- Haskell-Cafe - Haskell.org

On the parallel between java annotations and monads
by Rafael Almeida 03 Jul '09

03 Jul '09

Hello, After an extensive search (5 minutes googling) I could not find any comparison between Java annotations (or Python annotations for that matter) and Monads. I think they are similar in various aspects and I want to discuss them here. I'm sure several of you have experience with Java programming and its annotation system. At first they seem like an extension to the typing system, by using annotations a single variable or method may have more than one type: the real type and all the annotations types. The way you declare them is not important for this discussion, but assume that you've created the annotations GreaterThanFive and LessThanTwenty, you could annotate a method like this (let's forget about all the class verbosity for a while): @GreaterThanFive @LessThanTwenty int doYourThing(); You could than use reflection to read those annotations and you could check if the returned integer is in the correct range. You could even make the compiler generate code that will do that checking automatically for you. Even though that was my first impression of them, that's not really how they are used in practice (at least the practice that I have experimented). People use them to implement Monad-like features to the language. Actually, you can forget monad and think of computation containers. On an EJB environment there's something called a container and it will do all sorts of computations when you call an annotated method or when you create a new annotated class. For instance, if, inside of an entity bean, you annotate a variable like this: @Column(name = "NAME") private String name; then, when you create a method like so: public String getName() { return name; } that name is actually something retrieved from the database, even though, it looks just like something in memory. As far as I know the interaction with monads for handling databases is not very different. There are other annotations which allows the container to "inject" some object on a variable, such as: @PersistenceContext private EntityManager entityManager; now you won't even create an EntityManager instance, but will use the object living inside the container. I compare that to getting a value from an State Monad. Like there, you'll do some computations using entityManager, but it will ultimately be returned to the container. While each computational container in Haskell is very rigid and well defined, in java there's nothing rigorous about the annotation. However, quite often the annotations in Java are used in a manner similar to the implementation of a Monad in Java. []'s Rafael

3 2

hiding instance definitions in imported modules or redefining them, can it be done?
by John Lask 03 Jul '09

03 Jul '09

Is there a way to hide instance definitions when importing a module for instance I want to import Data.Monoid but wish to redefine the instance of Monoid for ( a->b) I don't suppose this is possible? Specifically, I wish to define a specialised instance of Monoid for String->Int, but it seems overlapping instances will not give me what I want, as this option seems to need to be applied at the definition site (aka Data.Monoid module, looking for confirmation of this?). The easy fix is just to do newtype M a b = M (a->b) etc..., but I was hopping to avoid this. I've encountered this issue several times. Why can't we redefine instances? I can't of thought that there are any seriouse technical issues in doing so? If so what are they? jvl

2 1

Monad Input/Output and Monad Transformers
by Maciej Piechotka 03 Jul '09

03 Jul '09

1. Learning haskell I discovered that I/O should be avoided nearly 'at all costs'. The problem is that the IO monad is the only one which have more interactive work flow. There is Reader/Writer monad but in fact AFAIU first one is about the environment and second one is about logging. Implementation of Writer can be defined in terms of handles but it is rather limited (either non-full implementation which may be confusing or need of caching the result for pass etc.). I searched the hackage but I didn't find package with pure I/O. Such package may look like: class (Monad m, Monoid v) => MonadInput v m where -- | Gets an element from input (line of text [with \n], 4096 bytes, -- or something like that). mzero on end getChunk :: m v class (Monad m, Monoid v) => MonadOutput v m where -- | Puts an element putChunk :: v -> m () In similar way filters (for example buffered input) can be defined: class (MonadInput v m) => MonadBufferedInput m where -- | If not whole chunk has been consumed at once (for example only -- first 3 elements from list) rest can be returned. It will be -- returned as part of the input on next getChunk call. returnChunk :: v -> m () data (MonadInput v m, Monoid v) => BufferedInputT v m a = BufferedInputT a v Also pipes may be defined (as far as I understand but I'm not 100% sure) which probably will simplify the writing of network tests: -- | Evaluates the first argument. If the getChunk is called the -- evaluation is passed to second argument until the putChunk is -- called, which argument is returned in the first argument callPipeT :: (Monad m, Monoid v) => PipeInputT v m a -> PipeOutputT v m b -> m (a, b) I've started some tests but I'd be grateful for comments (well - probably I'm not the first who come to this idea so a) there is such package or b) my level of Haskell does not allow me to see the problems). 2. I find writing monad transformers annoying. Additionally if package defines transformer A and another transformer B they need to be connected 'by hand'. I find a simple solution which probably is incorrect as it hasn't been used: instance (MonadState s n, Monad (m n), MonadTrans m) => MonadState s (m n) where get = lift get put = lift . put (requires FlexibleInstances MultiParamTypeClasses FlexibleContexts UndecidableInstances - two last are not extensions used by mtl) Regards

6 8

How to declare a Typeless Function
by Fernan Bolando 03 Jul '09

03 Jul '09

Hi I have a function that swaps rows of an array of double swap :: Array (Int,Int) Double -> [Int] -> Array (Int,Int) Double I then create a function that swaps rows of arrays of Complex Double swap :: Array (Int, Int) (Complex Double) -> [Int] -> Array (Int, Int) (Complex Double) In reality the function swap does not care whether its working on a double or a complex number. how do I declare swap so that it will work whether it's a complex or a double array. I tried googling but I wasn't sure what to google. fernan -- http://www.fernski.com

4 3

Re: Monad Input/Output and Monad Transformers
by John Lato 03 Jul '09

03 Jul '09

> From: Maciej Piechotka <uzytkownik2(a)gmail.com> > > 1. Learning haskell I discovered that I/O should be avoided nearly 'at > all costs'. The problem is that the IO monad is the only one which have > more interactive work flow. There is Reader/Writer monad but in fact > AFAIU first one is about the environment and second one is about > logging. Implementation of Writer can be defined in terms of handles but > it is rather limited (either non-full implementation which may be > confusing or need of caching the result for pass etc.). > I'm not sure what you mean when you say that IO is the only monad with a "more interactive work flow". Do you mean that it allows interleaving of input and output? If so, I would ask what you're doing that makes this a concern. If it's for efficiency, don't worry about it. Haskell's laziness means that the language will take care of this for you. A good example is the bzlib[1] package; the "compress" function has type "ByteString -> ByteString" and automatically handles the chunking of data for you. If you need to partially process an input to determine how the rest of the input should be handled, there are many parser libraries (parsec[2], polyparse[3], etc.) that can either help with this directly or perhaps give ideas as to how you can handle it. You may also want to look at the iteratee[4] package. It sounds like it may accomplish what you're trying to do, although the interface is very different from what you specify. > > 2. I find writing monad transformers annoying. > Additionally if package defines transformer A and another transformer B > they need to be connected 'by hand'. > If this becomes onerous, I think the usual solution is to define custom lifting functions for the most commonly performed operations. However, my feeling is that you're probably trying to put together a monad stack to model what you're trying to do too soon, when you'd be better served trying to develop data structures and core functions that describe what you want to do. Of course, without more information this is just a guess. John Lato [1] http://hackage.haskell.org/package/bzlib [2] http://legacy.cs.uu.nl/daan/parsec.html, http://hackage.haskell.org/package/parsec [3] http://www.cs.york.ac.uk/fp/polyparse/, http://hackage.haskell.org/package/polyparse [4] http://okmij.org/ftp/Haskell/Iteratee/, http://hackage.haskell.org/package/iteratee

1 0

Re: [Haskell-cafe] A Strict GCL Interpreter in Haskell
by Tillmann Rendel 03 Jul '09

03 Jul '09

Hi Hector, Hector Guilarte wrote: > I did that already, but it didn't work... Also, since this kind of error would be a run time error in my GCL Language, I don't want it to continue executing whenever an error is found, that's why I changed it back to just: > evalExpr:: Expr -> Tabla -> Int > > Instead of using the Either String Int... I think you misunderstand something. If you use (Expr -> Table -> Int), you are announcing: Whatever happens, I keep executing. If you use (Expr -> Table -> Either String Int), you are announcing: I may stop earlier because of some problem. Since may you want to stop earlier, you should use the second type. Let's look at a very small example, an interpreter for the following little language: data Expression = Literal Integer | Add Expression Expression | Divide Expression Expression Because of division by zero, an interpreter for this language may fail. So we have two kinds of return values: Sometimes we return a number, and sometimes we return an DivideByZero error. We can reflect that in a datatype: data Result = Number Integer | DivideByZeroError Now we can write our interpreter: eval :: Expression -> Result eval (Literal n) = Number n eval (Add a b) = case eval a of Number result_of_a -> case b of Number result_of_b -> Number (result_of_a + result_of_b) DivideByZeroError -> DivideByZeroError DivideByZeroError -> DivideByZeroError eval (Add a b) = case eval a of Number result_of_a -> case b of Number result_of_b -> if b == 0 then DivideByZeroError else Number (result_of_a + result_of_b) DivideByZeroError -> DivideByZeroError DivideByZeroError -> DivideByZeroError This interpreter will stop as soon as it encounters a division by zero, because we take care to return DivideByZeroError whenever we see a DivideByZeroError in one of the subterms. So you have to use an appropriate return type (like (Either String Int) or Result), and you have to pattern match on the result of "earlier" parts of your program, and propagate the error. Tillmann

2 1

Haskellers at University of Edinburgh? (hackathon)
by Eric Kow 03 Jul '09

03 Jul '09

Hi Haskellers, I'm looking for people at the University of Edinburgh who have a swipe card with access to the Informatics Forum and could hang around on 29 August (or perhaps 6 Sep). Thanks! PS. You may also be interested in some Hackathon news: we've reserved a room at the ICFP venue suitable for up to 50 people, but we can only have it for 30 August. I'm still holding out for a two-day space, but if I don't hear back by mid-week, we'll settle for a single Haskell Hack Day, preceded by a more informal Haskell Hacking Expedition the day before (for example, camping in in a wifi-enabled pub for the day). -- Eric Kow <http://www.nltg.brighton.ac.uk/home/Eric.Kow> PGP Key ID: 08AC04F9

7 7

[ghc] kind of the function arrow
by Dominic Orchard 03 Jul '09

03 Jul '09

I was just playing around and noticed that the kind of the function arrow in GHC is (?? -> ? -> *) when I (naively) expected it to be (* -> * -> *). After looking at (http://hackage.haskell.org/packages/archive/ghc/6.10.2/doc/html/Type.html#5) I see that the kind of (->) means that the parameter type cannot be an unboxed tuple, whilst the result type can be anything. Why is this? After reading this documentation I would expect the kind (? -> ? -> *). I'm now wondering if the kind of (->) could cause problems if the following style of declaration is requried: > type FunArg a b = (a -> b, a) *Main> :k FunArg FunArg :: * -> * -> * By using type variables, whose default kind is *, the function type is fixed to use only boxed types. But if one wanted to allow unboxed type parameters the kind would be wrong, and an explicit kind signature of # or ? can't be given as they are not part of Haskell's source language. I guess my question is why the (?? -> ? -> *) kind on (->) and what to do if synonyms or data types over (->) are required such as the example just stated. I'm just curious. Thanks, Dominic

2 1

Network.CGI -- practical web programming example.
by Edward Ing 02 Jul '09

02 Jul '09

I am somewhat new to haskell. It is amazing that I can actually write a CGI program using Network.CGI without really being comfortable with the Haskell type system. Especially when it involves monad transformations. So I decided that I better understand this. I looked at the Practical Web Programming examples to try to understand what is going on. I came up with a problem that might demonstrate my misunderstanding. I am wondering if you can answer questions I have. Code 1 is the example from PWP, Code 2 is my variation and it works so I am stumped by what the liftM is required. code 1>>> #!/usr/bin/runghc import Network.CGI import Text.XHtml import qualified Data.ByteString.Lazy as BS import Control.Monad (liftM) import Data.Maybe (fromJust) uploadDir = "../upload" fileForm = form ! [method "post", enctype "multipart/form-data"] << [afile "file", submit "" "Upload"] saveFile n = do cont <- (liftM fromJust) $ getInputFPS "file" let f = uploadDir ++ "/" ++ basename n liftIO $ BS.writeFile f cont return $ paragraph << ("Saved as " +++ anchor ! [href f] << f +++ ".") page t b = header << thetitle << t +++ body << b basename = reverse . takeWhile (`notElem` "/\\") . reverse cgiMain = do mn <- getInputFilename "file" h <- maybe (return fileForm) saveFile mn output $ renderHtml $ page "Upload example" h main = runCGI $ handleErrors cgiMain Code 2 (modifier) >>> import Network.CGI import Text.XHtml import qualified Data.ByteString.Lazy as BS import Control.Monad (liftM) import Data.Maybe (fromJust) uploadDir = "../upload" fileForm = form ! [method "post", enctype "multipart/form-data"] << [afile "file", submit "" "Upload"] saveFile n = do cont <- getInputFPS "file" let f = uploadDir ++ "/" ++ basename n liftIO $ BS.writeFile f (fromJust cont) return $ paragraph << ("Saved as " +++ anchor ! [href f] << f +++ ".") page t b = header << thetitle << t +++ body << b basename = reverse . takeWhile (`notElem` "/\\") . reverse cgiMain = do mn <- getInputFilename "file" h <- maybe (return fileForm) saveFile mn output $ renderHtml $ page "Upload example" h main = runCGI $ handleErrors cgiMain Questions === 1) Why did the author choose to insert "liftM" in function saveFile? It doesn't seem necessary in my version. 2) My background mainly is Java but here is my understanding of Monad Transforms. The CGIT m type carries around with it the CGI Request context and response contexts. The transformations (lifts) is similar to casting so that you can use the functions for specific manifestations but it also encapsulates the data. Is this correct? Edward

4 4

A Strict GCL Interpreter in Haskell
by Hector Guilarte 02 Jul '09

02 Jul '09

Hi everyone! (First of all, I don't know Monads!) I made a GCL (Guarded Command Language) Compiler and Interpreter for my Languages and Machines course in my University with alex, happy and ghc. I still have a doubt: 1) Since Haskell is Lazy, and my GCL program is being interpreted in Haskell then my GCL is Lazy too (I know is not as simple as that but believe me, somehow it is behaving lazy). The problem is that it can't be lazy (said to me by my teacher on monday) so I tried using seq, but it didn't work, I'll paste the code after this: Programs in GCL like: a) var i : value main i <- 1 / 0 end b) var i : value main i <- 1 / 0; show i end c) var i : value var foo : array of 2 main i <- foo[42] end d) var i : value var foo : array of 2 main i <- foo[42]; show i end act like this: a and c finish interpretation b throws division by zero error and finish interpretation d throws index out of bounds error and finish interpretation Now the code: (it is in Spanish. ListLValue is a List of L-Values for the assigments, ListExpr is the list of Expressions to be assigned, Tabla is the Symbol Table (Data.Map), actualizarVar updates a Variable in the Symbol Table with the new value "valor", ActualizarArray updates the position "indice" of an array in the Symbol Table. evalExpr evaluates an arithmetic Expression and returns an Int. Inside evalExpr are the verifications for division by zero of modulo by zero.) evalAsignacion:: ListLvalue -> ListExpr -> Tabla -> Tabla evalAsignacion [] [] tabla = tabla evalAsignacion ((Lid id):valueList) (expr:exprList) tabla = let valor = (evalExpr expr tabla) in valor `seq` evalAsignacion valueList exprList (actualizarVar id valor tabla) evalAsignacion ((LArrayPosition id exprArray):valueList) (expr:exprList) tabla = let valor = (evalExpr expr tabla) indice = (evalExpr exprArray tabla) in valor `seq` indice `seq` evalAsignacion valueList exprList (actualizarArray id indice valor tabla) evalExpr:: Expr -> Tabla -> Int evalExpr expr tabla = let salida = (snd (evalAritmetico expr tabla)) in salida `seq` if (isLeft salida) then error (getLeft salida) else getRight salida --((Int,Int) is the Line and Colum, that's for error reporting) evalAritmetico :: Expr -> Tabla -> ((Int,Int),(Either String Int)) --LET ME KNOW IF YOU NEED THIS PART TOO Thanks in advance, Hector Guilarte

3 2