- Haskell-Cafe - Haskell.org

15 Jan '12

Hi, I have a basic question concerning function composition. I have used http://www.haskell.org/tutorial/functions.html to write a composition function: Prelude> let f°g = f g Prelude> let p = (*2) Prelude> let q = (+3) Prelude> p°q 4 14 Prelude> :t (°) (°) :: (t1 -> t) -> t1 -> t If I understand well, this means that the infix operator "°" takes a function of type t1, i.e. g in f°g, and applies f on it, which takes a type t1 as input and returns f(g) which is of type t. The final result is of type t. So the first argument is represented above by "(t1->t)", and the second by "t1", the final result being of type t. However, I am not able to get the type of p°q Prelude> :t p°q <interactive>:1:3: Couldn't match expected type `Integer' with actual type `Integer -> Integer' In the second argument of `(°)', namely `q' In the expression: p ° q Prelude> What's the problem here? How can I obtain the type of p°q? Thanks in advance, TP

3 2

Installing dph-examples in Mac OS X Version 10.7.2
by mukesh tiwari 15 Jan '12

15 Jan '12

Hello all I am trying to install dph-examples on Mac OS X. First I have Xcode 4.2.1 and during the installation i got this <http://hpaste.org/56445> error Installing library in /Users/mukesh/.cabal/lib/dph-seq-0.5.1.1/ghc-7.2.1Registering dph-seq-0.5.1.1...Downloading dph-examples-0.5.1.2...Configuring dph-examples-0.5.1.2...Building dph-examples-0.5.1.2...Preprocessing executable 'dph-sumsq-seq' for dph-examples-0.5.1.2...[1 of 5] Compiling SumSquaresVectorised ( imaginary/SumSquares/dph/SumSquaresVectorised.hs, dist/build/dph-sumsq-seq/dph-sumsq-seq-tmp/SumSquaresVectorised.o )Error (fd:12: hGetLine: end of file)Warning: Couldn't figure out LLVM version!Make sure you have installed LLVMghc: could not execute: optcabal: Error: some packages failed to install:dph-examples-0.5.1.2 failed during the building phase. The exception was:ExitFailure 1 On stackoverflow<http://stackoverflow.com/questions/8864696/installing-dph-examples-in-mac-o…> , i got suggestion to remove Xcode 4.2 and install Xcode 3.2. After installing Xcode 3.2 , I am still getting this error. Macintosh:~ mukesh$ cabal install dph-examples Resolving dependencies... Configuring dph-examples-0.5.1.2... Building dph-examples-0.5.1.2... Preprocessing executable 'dph-sumsq-seq' for dph-examples-0.5.1.2... [1 of 5] Compiling SumSquaresVectorised ( imaginary/SumSquares/dph/SumSquaresVectorised.hs, dist/build/dph-sumsq-seq/dph-sumsq-seq-tmp/SumSquaresVectorised.o ) Error (fd:11: hGetLine: end of file) Warning: Couldn't figure out LLVM version! Make sure you have installed LLVM ghc: could not execute: opt cabal: Error: some packages failed to install: dph-examples-0.5.1.2 failed during the building phase. The exception was: ExitFailure 1 Macintosh:~ mukesh$ uname -a Darwin Macintosh 11.2.0 Darwin Kernel Version 11.2.0: Tue Aug 9 20:56:15 PDT 2011; root:xnu-1699.24.8~1/RELEASE_I386 i386 Macintosh:~ mukesh$ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.2.1 Xcode 3.2 ( 64 bit ) Could some one please tell me how to resolve this issue. Regards Mukesh Tiwari

1 0

Is it possible to create an instance of MonadBaseControl for PropertyM (QuickCheck)/continuations?
by Oliver Charles 15 Jan '12

15 Jan '12

Hi I'm working on a little experiment at the moment: using monadic QuickCheck to test the integration of my code and the database. I see some of my functions having properties like - given a database in this state, selectAll should return all rows, and so on. My initial attempt has worked nicely, and now I'm trying to test some more complicated properties, but I'm hitting a problem with overlapping primary keys, and this is because I'm not correctly cleaning up after each check. The simplest solution to this is to bracket property itself, and for that I turned to Control.Monad.Trans.Control in lifted-base, but I am struggling to actually write an instance for MonadBaseContol IO (PropertyM IO). It seems that PropertyM is a continuation monad transformer: newtype PropertyM m a = MkPropertyM { unPropertyM :: (a -> Gen (m Property)) -> Gen (m Property) } Given this, is it possible to even write an instance of MonadBaseControl? From the lifted-base documentation, it explicitly calls out ConT as *not* having instances, so I wonder if it can't be done. Sadly, I also lack intuition as to what MonadBaseControl really means - I think it means 'capture the state of this monad, so later we can go back to exactly the same state (or sequence of actions?)', but this is very flakey. So... is this possible, and if so how can I move forward? Thanks for any help or advice! - Ollie

1 0

parse error in pattern, and byte code interpreter
by TP 15 Jan '12

15 Jan '12

Hi everybody, I want to test a higher level language than C/C++ (type inference, garbage collection), but much faster than Python. So I am naturally led to Haskell or OCaml. I have read and tested tutorials for the two languages. For the time being, my preference goes to Haskell, first because it looks more like Python, and also because some things appear not so clean in OCaml, at least for a beginner (Put a line termination or not? Why have I to put "rec" in the definition of a recursive function? Etc.). I have two questions. 1/ Inspiring from tutorials out there, I have tried to write a small formal program which is able to distribute n*(x+y) to n*x+n*y. The OCaml version is working (see Post Scriptum). However, I have difficulties to make the Haskell version work. This is my code: {----------------------------------------------------} data Expr = Plus Expr Expr | Minus Expr Expr | Times Expr Expr | Divide Expr Expr | Variable String deriving ( Show, Eq ) expr_to_string expr = case expr of Times expr1 expr2 -> "(" ++ ( expr_to_string expr1 ) ++ " * " ++ ( expr_to_string expr2 ) ++ ")" Plus expr1 expr2 -> "(" ++ ( expr_to_string expr1 ) ++ " + " ++ ( expr_to_string expr2 ) ++ ")" Variable var -> var distribute expr = case expr of Variable var -> var Times expr1 Plus( expr2 expr3 ) -> Plus ( Times ( expr1 expr2 ) Times ( expr1 expr3 ) ) main = do let x = Times ( Variable "n" ) ( Plus ( Variable "x" ) ( Variable "y" ) ) print x print ( expr_to_string x ) {----------------------------------------------------} When I try to run this code with "runghc", I obtain: pattern_matching_example.hs:28:24: Parse error in pattern: expr2 Thus it does not like my pattern "Times expr1 Plus( expr2 expr3 )". Why? How can I obtain the right result, as with the OCaml code below? 2/ It seems there is no possibility to generate bytecode, contrary to OCaml. Is it correct? Is there an alternative? What is interesting with bytecode run with "ocamlrun" is that the process of generating the bytecode is very fast, so it is very convenient to test the program being written, in an efficient workflow. Only at the end the program is compiled to get more execution speed. Thanks a lot in advance. TP PS: --- To test the OCaml tutorial, type: $ ocamlc -o pattern_matching_example pattern_matching_example.ml $ ocamlrun ./pattern_matching_example (*************************************************************) (* from OCaml tutorial, section 'data_types_and_matching.html' *) (* This is a binary tree *) type expr = Plus of expr * expr | Minus of expr * expr | Times of expr * expr | Divide of expr * expr | Value of string ;; let v = Times ( Value "n", Plus (Value "x", Value "y") ) let rec to_string e = match e with Plus ( left, right ) -> "(" ^ (to_string left ) ^ " + " ^ (to_string right) ^ ")" | Minus ( left, right ) -> "(" ^ (to_string left ) ^ " - " ^ (to_string right) ^ ")" | Times ( left, right ) -> "(" ^ (to_string left ) ^ " * " ^ (to_string right) ^ ")" | Divide ( left, right ) -> "(" ^ (to_string left ) ^ " / " ^ (to_string right) ^ ")" | Value value -> value ;; (* by type inference, ocaml knows that e is of type expr just below *) let print_expr e = print_endline ( to_string e );; print_expr v;; let rec distribute e = match e with Times ( e1, Plus( e2, e3 ) ) -> Plus (Times ( distribute e1, distribute e2 ) , Times ( distribute e1, distribute e3 ) ) | Times ( Plus( e1, e2 ), e3 ) -> Plus (Times ( distribute e1, distribute e3 ) , Times ( distribute e2, distribute e3 ) ) | Plus ( left, right ) -> Plus ( distribute left, distribute right ) | Minus ( left, right ) -> Minus ( distribute left, distribute right ) | Times ( left, right ) -> Times ( distribute left, distribute right ) | Divide ( left, right ) -> Divide ( distribute left, distribute right ) | Value v -> Value v ;; print_expr ( distribute v );; (*************************************************************)

2 1

Haskell Propaganda needed
by Victor Miller 15 Jan '12

15 Jan '12

I'm a research mathematician at a research institute with a bunch of other mathematicians (a number of whom are also expert programmers). I recently (starting three months ago) have been learning Haskell. I'm going to give a talk to the staff about it. Most of the audience are pretty experienced programmers in C/C+/Python, but with little or no exposure to functional languages. I'm looking for talks from which I can cannibalize good selling points. I was led to Haskell by a somewhat circuitous route: at our place, as with most of the world, parallel programs (especially using GPUs) are becoming more important. A little googling lead me a few interesting projects on automatic mapping computations to GPUs, all of which were based on Haskell. I feel that this will be the way to go. There's one guy on the staff who's a demon programmer: if someone needs something to be adapted to GPUs they go to him. Unfortunately I find reading his code rather difficult -- it's rather baroque and opaque. Thus, I'd like something more high level, and something amenable to optimization algorithms. In my former life I worked at IBM research on one of the leading edge compiler optimization projects, and learned to appreciate the need for clear semantics in programs, not just for developing correct programs, but also to allow really aggressive optimizations to be performed. This is another reason that I'm interested in functional languages. I know that I'll get peppered with questions about efficiency. We (our staff) is interested in *very* large scale computations which must use the resources as efficiently as possible. One of our staff members also opined that he felt that a lazy language like Haskell wouldn't be acceptable, since it was impossible (or extremely difficult) to predict the storage use of such a program. So, any suggestions are welcome. Victor

2 1

STM atomic blocks in IO functions
by Rob Stewart 15 Jan '12

15 Jan '12

Hi, My question is regarding the correct us of STM in Haskell. I have put to together a simple example, which represents more verbose code in a library that I am writing. The question is a simple one. Must all operations on a TVar happen within *the same* atomically block, or am I am I guaranteed thread safety if, say, I have a number of atomically blocks in an IO function. Here's my example: http://pastebin.com/Hit5vKmk . Is this example permissible? thanks, -- Rob Stewart

6 6

decoupling type classes
by Yin Wang 14 Jan '12

14 Jan '12

Hi all, I have an idea about type classes that I have been experimenting. It appears to be a generalization to Haskell’s type classes and seems to be doable. It seems to related the three ideas: type classes, implicit parameters, and (typed) dynamic scoping. But I don't know whether it is good or not. I hope to get some opinions before going further. Basically, Haskell’s type classes passes dictionaries around. Each dictionary contains one or more “methods”. When “names” which belong to a dictionary are called, we invoke functions that match its principle type in the call site's scope. I have an experimental system which “decouples” the dictionary. Instead of passing on a dictionary, it passes individual “implicit parameters" around. Those implicit parameters are type inferenced and they can contain type parameters just as methods in a type class. Similarly, they are resolved by their types in the call site's scope. The convenience of this approach compared to Haskell’s type classes is that we no longer require a user of a type class to define ALL the methods in a type class. For example, a user could just define a method + without defining other methods in the Num class: -, *, … He can use the method + independently. For example, if + is defined on the String type to be concatenation, we can use + in another function: weirdConcat x y = x + y + y This has a utility, because the methods in the Num class don’t “make sense” for Strings except +, but the current type class design requires us to define them. Note here that weirdConcat will not have the type (Num a) => a -> a -> a, since we no longer have the Num class, it is decoupled into separate methods. There is another benefit of this decoupling: it can subsume the functionality of MPTC. Because the methods are no longer grouped, there is no “common” type parameter to the methods. Thus we can easily have more than one parameter in the individual methods and conveniently use them as MPTC methods. SOME IMPLEMENTATION DETAILS Here is how it can be implemented. When we see an “undefined” variable in a function definition which has been declared as “overloaded function”, we store the function name, and the type variables that are associated with it. For example, overload g — (explicitly declare g as an overloaded function) f x y (String s) = … … let z = g x s y in … … We don’t know what x and y are, but we know from the body of f that their types satisfy this pattern: g ’a String ’b. Thus we store this pattern constraint as an extra (implicit) argument in the type of f: f :: a → b → String (exist g: g a String b) We may have multiple such arguments. At the call sites of f, we look for a function g in the scope that satisfies the pattern g ‘a String ’b, but we don’t pass on the substitution, so they remain polymorphic. Once found, the function is passed as an extra parameter to f. This is essentially dictionary passing, but without grouping. It can be also more efficient because the parameters may be stored in registers. Here g is explicitly declared as “overloaded”, although my experimental system doesn’t need this. Any undefined variable inside function body automatically becomes overloaded. This may cause unintended overloading and it catches bugs late. That’s why we need the “overload” declarations. But the automatic overloading of the undefined may be useful in certain situations. For example, if we are going to use Haskell as a shell language. Every “command” must be evaluated when we type them. If we have mutually recursive definitions, the shell will report “undefined variables” either way we order the functions. The automatic overloading may solve this problem. The undefined variables will temporarily exist as automatic overloaded functions. Once we actually define a function with the same name AND satisfies the type constraints, they become implicit parameters to the function we defined before. If we call a function whose implicit parameters are not associated, the shell reports error very similar to Haskell’s “type a is not of class Num …” RELATIONSHIP TO DYNAMIC SCOPING It seems to be helpful to think of the “method calls” as referencing dynamically scoped variables. They are dispatched depending on the bindings we have in the call site's scope (and not the scope where the method is defined!). So it is very much similar to the much-hated dynamic scoping. But the dispatching is more disciplined — it doesn't just match the name. It must match both the name and the inferred principle type. This intuition also explains why local instances shouldn't be allowed, because if we capture the variables at the definition site, the method call becomes "statically scoped". -- yin

2 2

[ANNOUNCE] JuicyPixels 1.0 - image loading library
by Vincent Berthoux 14 Jan '12

14 Jan '12

Hello, I'd like to announce the first release of JuicyPixels, an image loading library written entirely in Haskell. The focus of this library is ease of use and correct loading. In this first version the library is capable of the following actions : - PNG (.png) * Reading - 1,2,4,8 bits loading, Grayscale, 24bits, 24 bits with alpha, interleaved & filtered (fully compliant with the standard, tested against png suite). * Writing - 8bits RGB (non interleaved) - 8bits RGBA (non interleaved) - 8bits greyscale (non interleaved) - Bitmap (.bmp) (mainly used as a debug output format) * Reading - 24bits (RGB) images * Writing - 32bits (RGBA) per pixel images - 24bits (RGB) per pixel images - 8 bits greyscale (with palette) - Jpeg (.jpg, .jpeg) * Reading non-interlaced baseline DCT image, seems to be OK * Writing : none yet I'm interested on any feedback regarding ease of use, performance and bugs. GitHub : https://github.com/Twinside/Juicy.Pixels Hackage : http://hackage.haskell.org/package/JuicyPixels Thanks Vincent Berthoux

2 1

named pipes interface
by Serge D. Mechveliani 14 Jan '12

14 Jan '12

I thank people for the notes. People write that the example without unsafePerformIO is desirable. So I present the improved question and improved, "pure" code. ---------------------------------------------------------------------- I need to organize a string interface for a Haskell function Main.axiom and a C program fifoFromA.c via a pair of named pipes (in Linux, UNIX). The pipes are created before running, by the commands > mkfifo toA > mkfifo fromA Main.axiom outputs a string to toA and inputs the respond string from fromA as the result. fifoFromA inputs a string from toA, converts it to the string resStr, outputs resStr to fromA. Main.axiom must be able to be applied in a loop, and there must be avoided repeated opening of a file/channel in a loop. As an example, the string conversion in fifoFromA.c is put the conversion of each character to the lower case: -------------------------- fifoFromA.c ------------------------------ #include <string.h> #include <stdio.h> #include <fcntl.h> #define BOUND 64 int main() { int toA, fromA, i, numread; char buf[BOUND]; toA = open("toA", O_RDONLY); fromA = open("fromA", O_WRONLY); for (;;) { numread = read(toA, buf, BOUND); buf[numread] = '\0'; // printf("A: Read from toA: %s\n", buf); i = 0; // convert the string to the lower case while (i < numread) {buf[i] = tolower(buf[i]); i++;} write(fromA, buf, strlen(buf)); } } ----------------------------------------------------------------------- For the "to-A" part writen in C (instead of Haskell), this interface loop works all right. With Haskell, I manage to process only the first string in the loop, and then it ends with an error. Main.hs is given below. Can you, please, fix the code? Please, copy the response to mechvel(a)botik.ru Thanks, ------ Sergei mechvel(a)botik.ru ------------------------------------------------------------------------ import System.IO (IOMode(..), IO(..), Handle, openFile, hPutStr, hGetLine, hFlush) dir = showString "/home/mechvel/ghc/axiomInterface/byLowerLevel/" toA_IO = openFile (dir "toA") WriteMode :: IO Handle -- used as global values fromA_IO = openFile (dir "fromA") ReadMode -- axiomIO :: String -> IO String axiomIO str = do toA <- toA_IO fromA <- fromA_IO hPutStr toA str hFlush toA hGetLine fromA ---------------------------------------------- Example of usage -- main = do putStr "str1 --> " str1' <- axiomIO str1 putStr (str1' ++ "\n") putStr "str2 --> " str2' <- axiomIO str2 putStr (str2' ++ "\n") where n = 9 str0 = "ABC" strings = [str0 ++ (show i) | i <- [1 .. n]] str1: str2: _ = strings ------------------------------------------------------------------ I use Glasgow Haskell ghc-7.01. Build: > gcc -o fifoFromA fifoFromA.c > ghc --make Main Running: first, command > ./fifoFromA on terminal-2, then command > ./Main on terminal-1. And it processes only the first string: terminal-1: m> ./Main str1 --> abc1 str2 --> Main: /home/mechvel/m/toA: openFile: does not exist (No such device or address)

1 0

Code generation and optimisation for compiling Haskell
by Steve Horne 13 Jan '12

13 Jan '12

Although I'm far from being an expert Haskell programmer, I think I'm ready to look into some of the details of how it's compiled. I've a copy of Modern Compiler Design (Grune, Bal, Jacobs and Langendoen) - I first learned a lot of lexical and parsing stuff from it quite a few years ago. Today, I started looking through the functional languages section - I've read it before, but never absorbed much of it. Graph reduction, lambda lifing, etc - it seems pretty simple. Far too simple. It's hard to believe that decent performance is possible if all the work is done by a run-time graph reduction engine. Simon Peyton Jones has written a couple of books on implementing functional languages which are available for free download. At a glance, they seem to covers similar topics in much more detail. However, they're from 1987 and 1992. Considering SPJs period "of despair" when he couldn't get practical performance for monadic I/O, these seem very dated. Some time ago, I made a note to look up the book "Functional Programming and Parallel Graph Rewriting" (I forget why) but again that's from the early 90's. I've also got a note to look up Urban Boquists thesis. SPJ also has some papers on compilation - http://research.microsoft.com/en-us/um/people/simonpj/papers/papers.html#co… - and the papers on optimisation by program transformation have caught my eye. Are there any current text-books that describe the techniques used by compilers like GHC to generate efficient code from functional languages? It's OK to assume some knowledge of basic compiler theory - the important stuff is code generation and optimisation techniques for lazy functional languages in particular. Also, what papers should I read? Am I on the right lines with the ones I've mentioned above?

4 5