- Haskell-Cafe - Haskell.org

Error and warning messages with -O
by Marco Túlio Gontijo e Silva 29 Jan '07

29 Jan '07

Hello, I was trying to compile a library I wrote with cabal, but I couldn't because of -O. I tried removing it and it worked ok. Then I noticed that -O was giving some warnings and an error that are not present without it: marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ /usr/bin/ghc -package-name HaskellGPC-0.0.1 --make -hide-all-packages -i -idist/build/autogen -i. -odir dist/build -hidir dist/build -package base-2.0 -O -Wall -Werror -fffi Algebra.Geometric.Gpc [1 of 1] Compiling Algebra.Geometric.Gpc ( Algebra/Geometric/Gpc.hs, dist/build/Algebra/Geometric/Gpc.o ) /tmp/ghc5871_0/ghc5871_0.hc:5:35: error: Algebra/Geometric/Gpc.h: Arquivo ou diretório não encontrado /tmp/ghc5871_0/ghc5871_0.hc: In function ‘r2Hk_entry’: /tmp/ghc5871_0/ghc5871_0.hc:290:0: warning: implicit declaration of function ‘gpc_polygon_clip’ /tmp/ghc5871_0/ghc5871_0.hc: In function ‘r2Hm_entry’: /tmp/ghc5871_0/ghc5871_0.hc:327:0: warning: implicit declaration of function ‘gpc_free_polygon’ marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ /usr/bin/ghc -package-name HaskellGPC-0.0.1 --make -hide-all-packages -i -idist/build/autogen -i. -odir dist/build -hidir dist/build -package base-2.0 -Wall -Werror -fffi Algebra.Geometric.Gpc [1 of 1] Compiling Algebra.Geometric.Gpc ( Algebra/Geometric/Gpc.hs, dist/build/Algebra/Geometric/Gpc.o ) marcot@quindinho:~/codigo/haskell/haskellgpc/haskellgpc$ Why can't I use -O? Thanks. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria(a)riseup.net Jabber (GTalk): malebria(a)jabber.org Ekiga: malebria(a)ekiga.net IRC: malebria(a)irc.freenode.net malebria(a)irc.oftc.org Skype: marcotmarcot Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

1 1

Happy outputs "parE" - ideas on what to change in my .y file?
by Mark Wassell 29 Jan '07

29 Jan '07

Sometimes happy outputs 'parE' when I run it on my .y file? I believe it is coming from a part of Grammer.lhs which has the comment line "This bit is a real mess, mainly because of the error message support." Are there any suggestions on what to change in my .y file to get over this? Thanks Mark

2 1

Multiparamater class type-inference error
by Alfonso Acosta 29 Jan '07

29 Jan '07

Hi all, Sorry if this is too GHC-specific. I'm getting this strange instantiation error when compiling the following code with GHC 6.6: No instance for (Synchronous s ((a, b) -> a) (a, b) a) arising from use of `mapSY' at SynchronousLib.lhs:342:8-16 Possible fix: add an instance declaration for (Synchronous s ((a, b) -> a) (a, b) a) In the expression: mapSY fst In the definition of `fstSY': fstSY = mapSY fst --- data Signal a = NullS | a :- Signal a deriving (Eq) class Synchronous s f1 a b | f1 -> a , f1 -> b where mapSY :: f1 -> s a -> s b delaySY :: a -> s a -> s a instance Synchronous Signal (a->b) a b where mapSY _ NullS = NullS mapSY f (x:-xs) = f x :- (mapSY f xs) delaySY e es = e:-es fstSY = mapSY fst {-- No instance for (Synchronous s ((a, b) -> a) (a, b) a) arising from use of `mapSY' at SynchronousLib.lhs:342:8-16 Possible fix: add an instance declaration for (Synchronous s ((a, b) -> a) (a, b) a) In the expression: mapSY fst In the definition of `fstSY': fstSY = mapSY fst Failed, modules loaded: AbsentExt, Vector, Queue, Signal. --} -- No error arises if fstSY is declared as fstSY a = mapSY fst a Is it GHC bug or am I supposed to declare it like that to assist type inference? Thanks in advance, Alfonso Acosta

2 2

Re: Extensible static checking of dimensions?
by Björn Buckwalter 29 Jan '07

29 Jan '07

Mike Gunter <m <at> ryangunter.com> wrote: | The very nice Buckwalter and Denney dimensional-numbers packages both | work on a fixed set of base dimensions. This is a significant | restriction for me--I want to avoid adding apples to oranges as well | as avoiding adding meters to grams. Is it possible to have an | extensible set of base dimensions? If so, how usable can such a | system be made? Is it very much worse than a system with a fixed set | of base dimensions? Mike, I apologize for not having replied to your message earlier, I have not been subscribing to the café and only recently noticed your post in the archives. As for you question, please see the literate haskell module below. It allows you to extend the set of SI base dimensions in 'Buckwalter.Dimensional' with an arbitrary number of extra dimensions. My hope is that it lifts the significant restriction you saw previously. As for the usability of such a system, once you have set up the dimensions relevant to your problem domain usage should be identical to (and seamless with) the original base dimensions. You will have to be the judge as to whether it is usable enough for you. I would certainly appreciate comments on usability. In fact I would also be interested to hear how you envision applying the functionality you requested, regardless of this modules usefulness. Also, I can't promise that the module is rock solid -- I haven't done a whole lot of testing. If you don't have the 'Buckwalter.NumTypes' and 'Buckwalter.Dimensional' modules already you can download the latest tarball with all three modules from the project web site at: http://code.google.com/p/dimensional/ Thanks, Björn Buckwalter ~~~~~~~~~~ BEGIN 'Buckwalter/Dimensional/Extensible.lhs' ~~~~~~~~~~ Buckwalter.Dimensional.Extensible -- Extensible physical dimensions Bjorn Buckwalter, bjorn.buckwalter(a)gmail.com License: BSD3 = Summary = On January 3 Mike Gunter asked[1]: | The very nice Buckwalter and Denney dimensional-numbers packages | both work on a fixed set of base dimensions. This is a significant | restriction for me--I want to avoid adding apples to oranges as | well as avoiding adding meters to grams. Is it possible to have | an extensible set of base dimensions? If so, how usable can such | a system be made? Is it very much worse than a system with a fixed | set of base dimensions? In this module we facilitate the addition an arbitrary number of "extra" dimensions to the seven base dimensions defined in 'Buckwalter.Dimensional'. A quantity or unit with one or more extra dimensions will be referred to as an "extended dimensional". = Preliminaries = Similarly with 'Buckwalter.Dimensional' this module requires GHC 6.6 or later. > {-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-} > module Buckwalter.Dimensional.Extensible > where > import Prelude hiding > ((*), (/), (+), (-), (^), sqrt, negate, pi, sin, cos, exp) > import qualified Prelude as P ((*), sin, cos, exp) > import Buckwalter.NumType (NumType, Add, Sub, Halve, Negate, Zero, Pos1) > import Buckwalter.Dimensional hiding (square, cubic, sin, cos, exp) = DExt, Apples and Oranges = We define the datatype 'DExt' which we will use to increase the number of dimensions from the seven SI base dimensions to an arbitrary number of dimensions. We make 'DExt' an instance of 'Dims' allowing us to use the 'Dimensional' type without change. > data (NumType n, Dims d) => DExt n d > instance Dims (DExt n d) Using 'DExt' we can define type synonyms for extended dimensions applicable to our problem domain. For exampel, Mike Gunter could define the 'Apples' and 'Oranges' dimensions and the corresponding quantities. ] type DApples = DExt Pos1 (DExt Zero DOne) ] type DOranges = DExt Zero (DExt Pos1 DOne) ] type Apples = Quantity DApples ] type Oranges = Quantity DOranges And while he was at it he could define corresponding units. ] apple :: Num a => Unit DApples a ] apple = Dimensional 1 ] orange :: Num a => Unit DOranges a ] orange = Dimensional 1 = Arithmetic = We get negation, addition and subtracton for free with extended dimensionals. However, we will need instances of the 'Mul', 'Div' and 'Sqrt' classes for the corresponding operations to work. > instance (Add n n' n'', Mul d d' d'') > => Mul (DExt n d) (DExt n' d') (DExt n'' d'') > instance (Sub n n' n'', Div d d' d'') > => Div (DExt n d) (DExt n' d') (DExt n'' d'') > instance (Halve n n', Sqrt d d') => Sqrt (DExt n d) (DExt n' d') Now, in order to work seamlessly with the quantities and units defined in 'Buckwalter.Dimensional' we must be able to automatically extend their dimensions when multiplying or dividing by an extended dimensional. > instance (Mul d (Dim l m t i th n j) d') => Mul (DExt x d) > (Dim l m t i th n j) > (DExt x d') > instance (Mul (Dim l m t i th n j) d d') => Mul (Dim l m t i th n j) > (DExt x d) > (DExt x d') > instance (Div d (Dim l m t i th n j) d') => Div (DExt x d) > (Dim l m t i th n j) > (DExt x d') > instance (Div (Dim l m t i th n j) d d', Negate x x') > => Div (Dim l m t i th n j) > (DExt x d) > (DExt x' d') The above instances also enable taking integer powers of extended dimensionals. To allow dimensionless quantities to be raised to the power of any other dimensionless quantity (where either or both of the quantities may be an extended dimensional) some new 'Power' instances are required. > instance (Floating a, Power a d (Dimensionless a) DOne) > => Power a (DExt Zero d) (Dimensionless a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) > instance (Floating a, Power a DOne (Quantity d a) DOne) > => Power a DOne (Quantity (DExt Zero d) a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) > instance (Floating a, Power a d (Quantity d' a) DOne) > => Power a (DExt Zero d) (Quantity (DExt Zero d') a) DOne > where (Dimensional x) ^ (Dimensional y) = Dimensional (x ** y) Note that the extra dimensions are dropped from the result. This is acceptable since they will be added again as necessary when multiplying or dividing by extended dimensionals. = Elementary functions, 'square' and 'cubic' = In 'Buckwalter.Dimensional' the elementary functions where restricted to dimensionals with the physical dimension 'DOne'. The same applies to the 'square' and 'cubic' functions and the 'DLength' dimension respectively. Unfortunately this implementation is inflexible in that it will not accomodate extended dimensionals even if they have no extend into the extra dimensions (i.e. the powers are all 'Zero'). To solve this problem we must provide new, generalized implementations of such functions. We start by defining the class 'BaseDim' which relates extended dimensions to the corresponding base dimension if applicable. An extended dimension has a corresponding base dimension if the powers of all extra dimensions are 'Zero'. Two 'BaseDim' instances are required. > class BaseDim d d' | d -> d' > instance BaseDim (Dim l m t i th n j) (Dim l m t i th n j) > instance (BaseDim d d') => BaseDim (DExt Zero d) d' Using 'BaseDim' in the constraints we can now redefine the elementary functions. As with the 'Power' instances above we drop the extra dimensions from the results. > sin, cos :: (Floating a, BaseDim d DOne) => Quantity d a -> Dimensionless a > sin (Dimensional x) = Dimensional (P.sin x) > cos (Dimensional x) = Dimensional (P.cos x) > exp :: (Floating a, BaseDim d DOne) => Quantity d a -> Dimensionless a > exp (Dimensional x) = Dimensional (P.exp x) Ditto for 'square' and 'cubic'. > square :: (Num a, BaseDim d DLength) => Unit d a -> Unit DArea a > square (Dimensional x) = Dimensional (x P.* x) > cubic :: (Num a, BaseDim d DLength) => Unit d a -> Unit DVolume a > cubic (Dimensional x) = Dimensional (x P.* x P.* x) (As a side note we could probably use 'BaseDim' to clean up the constraints and/or reduce the instances of 'Power' above, and perhaps for 'Mul' and 'Div'.) = References = [1] http://www.haskell.org/pipermail/haskell-cafe/2007-January/021069.html

1 0

Re: Haskell Weekly News: January 02, 2007
by Björn Buckwalter 28 Jan '07

28 Jan '07

Henning Thielemann <lemming <at> henning-thielemann.de> writes: > On Tue, 2 Jan 2007, Donald Bruce Stewart wrote: > > > Dimensional: Statically checked physical dimensions. Björn Buckwalter > > [4]announced version 0.1 of [5]Dimensional, a module for statically > > checked physical dimensions. The module facilitates calculations with > > physical quantities while statically preventing e.g. addition of > > quantities with differing physical dimensions. > > > > 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14691 > > 5. http://code.google.com/p/dimensional/ Henning, First, let me apologize for not answering earlier. I have been reluctant to subscribe to the café due to the volume of messages. Instead I tend to occasionally browse the archives. Needless to say your questions eluded me until now. The same is true for Mike Gunter's message[1] which I will respond to presently. > How is it related to this one: > http://www.haskell.org/haskellwiki/Dimensionalized_numbers > ? I ashamedly admit that I am guilty of inventing my own wheel. I haven't looked too closely at Aaron's code but I believe there are some conceptual similarities. Regarding completeness user my library supports all seven base dimensions while Aaron's library currently supports only length and time (I believe it is meant as a proof of concept (toy example in his own words) rather than a complete library). My ambition is to provide a reasonably complete library. > It should certainly be mentioned on > http://www.haskell.org/haskellwiki/Physical_units > http://www.haskell.org/haskellwiki/Libraries_and_tools/Mathematics#Physical… I have added it to the above pages. Thanks, Björn Buckwalter [1] http://www.haskell.org/pipermail/haskell-cafe/2007-January/021069.html

1 0

Converting Types to Terms
by Klaus Ostermann 28 Jan '07

28 Jan '07

I would like to have a program that can synthesize programs for a given type, composing only functions from a given library. For example, suppose my library has isZero :: Int -> Bool map :: (a -> b) -> [a] -> [b] and :: Bool -> Bool -> Bool fold :: (a -> b -> a) -> a -> [b] -> a True :: Bool (.) :: (b -> c) -> (a -> b) -> a -> c then I want to ask, say, for a program of type [Int] -> Bool and get as answer (fold and True) . (map isZero) I have found two approaches in this direction. The first one is the De-Typechecker http://www.haskell.org/pipermail/haskell/2005-March/015423.html and the other one is Djinn http://permalink.gmane.org/gmane.comp.lang.haskell.general/12747 However, with none of these approaches I managed to do anything with list functions. What else is available (besides Djinn and De-Typechecker)? Are lists a problem? In general, what are the practical and theoretical limits of these program synthesizers? Are there any overview papers for this topic? Regards, Klaus

3 2

Numeric Class Problem
by Dennis Buchmann 28 Jan '07

28 Jan '07

I've got a little problem i don't understand. I need to calculate an index for a list (by use of !!). It should look like this: floor(j * (n / p2n)) where j is an Integer, n is the length of a list, therefore Integer too, and p2n is 2^n. When i use the former line in my Haskell code (pasted at the end of this mail), i get the following error message: qc.lhs:464:16: No instance for (RealFrac Int) arising from use of `floor' at qc.lhs:464:16-36 Possible fix: add an instance declaration for (RealFrac Int) In the expression: floor (j * (n / p2n)) In the definition of `i': i = floor (j * (n / p2n)) In the definition of `genUf'': genUf' f j n | j == p2n = [] | otherwise = [(replicate (j + (y1 - y0)) 0) ++ ([1] ++ (replicate (p2n - ((j + (y1 - y0)) + 1)) 0))] ++ (genUf' f (j + 1) n) where y0 = mod j 2 y1 = xor y0 (f !! i) xor a b = mod (a + b) 2 p2n = (2 ^ n) i = floor (j * (n / p2n)) Failed, modules loaded: none. ------------------------------------------------------------------------ genUf :: [Int] -> QOp genUf f = (QOp(genUf' f 0 (length f))) where p2n = 2 ^ (length f) {- ok -} genUf' f j n | j == p2n = [] {- ok -} | otherwise = [(replicate (j+(y1-y0)) 0) ++ [1] ++ (replicate (p2n-(j+(y1-y0)+1)) 0)] ++ (genUf' f (j+1) n) where y0 = mod j 2 y1 = xor y0 (f!!i) xor a b = mod (a+b) 2 p2n = (2 ^ n) i = floor (j * (n / p2n))

3 2

Re: [Haskell-cafe] Glasgow Distributed Haskell
by Paul Johnson 28 Jan '07

28 Jan '07

Joel Reymont <joelr1(a)gmail.com> wrote: > I'm after Erlang in Haskell, if you will, for fault-tolerance and > scalability. I think the way to do Erlang in Haskell is to build a middleware layer on top of the language, not try to make the language into something it is not. In this kind of environment you need to be able to upgrade components while the system is running. The careful Haskell habit of separating stateful operations from pure functions is useful here. I gather that the HAppS project is working along similar lines, and for similar reasons. Take a look at it. http://happs.org/HAppS/README.html Paul.

2 1

Lazy ByteString Problem
by Dominic Steinitz 28 Jan '07

28 Jan '07

I've been playing around with streams as a way of implementing cryptographic functions as they seem to allow you to write code that reads more like the specification. However, I believe (and profiling seems to confirm this) that this builds up a large expression which only gets evaluated at the very end. I naively thought that using lazy bytestrings would solve the problem but the bytestring version just hangs even for small numbers. So two questions: 1. Are lazy bytestrings the answer but I am using them incorrectly? 2. What techniques are there to force evaluation and throw things that are no longer needed away? And can this be done without losing the spirit of the specification? Dominic. module Main(main) where import Data.Word import Data.Bits import Data.Char import System.Environment import qualified Data.ByteString.Lazy as BS -- ByteString version cbcl iv ps = ciphers where ciphers = 0xff `BS.cons` (BS.pack (BS.zipWith (+) feedIns ciphers)) feedIns = BS.pack (BS.zipWith xor (iv `BS.cons` ciphers) ps) -- Made up function to illustrate problem cbc iv ps = ciphers where ciphers = 0xff:(zipWith (+) feedIns ciphers) feedIns = zipWith xor (iv:ciphers) ps testl n = BS.last (cbcl 0x55 ((BS.pack . take n . repeat . fromIntegral . ord) 'a')) test :: Int -> Word8 test n = last (cbc 0x55 ((take n . repeat . fromIntegral . ord) 'a')) main = do progName <- getProgName args <- getArgs if length args /= 1 then putStrLn ("Usage: " ++ progName ++ " <length of string>") else (putStrLn . show . test . read) (args!!0)

1 1

Re: getting started with hsc (supercollider)
by Rohan Drape 28 Jan '07

28 Jan '07

Hello Alex, alex <alex(a)slab.org> writes: | Would anyone have some illustrative example code, and perhaps a | couple of tips for how to get things working well in emacs? Noting that Hsc is still experimental and not completely nailed down, though I think now quite close, and assuming that SuperCollider and ghc and emacs and the standard haskell emacs mode [1] are all installed and working, the following should get you started. * get hsc, or update if you have it (important, recent fixes required) darcs get http://slavepianos.org/rd/sw/sw-69 * compile it cd sw-69 runhaskell Setup.hs configure --prefix ~ runhaskell Setup.hs build runhaskell Setup.hs install --user (or there is a Makefile to do these three steps...) * add an appropriately modified variant of the following to ~/.emacs (push "/home/rohan/sw/sw-69/emacs" load-path) (setq hsc-interpreter "ghci") (setq hsc-help-directory "/home/rohan/sw/sw-69/Help/") (require 'hsc) * start the supercollider server scsynth -u 57110 That ought to be the end of premilinaries, this message is a 'literate SuperCollider Haskell file', save it with a .lhs extension, open it in emacs, make sure the Hsc menu comes up and read on. You can start ghci and load Sound.SC3 by typing C-cC-s (Hsc -> Haskell -> Start haskell). If the ghci output window becomes obscured you can see it again by typing C-cC-g (Hsc -> Haskell -> See output). The SuperCollider convention is that ordinary graph nodes are placed in a group with identifier 1, this node is not created when scsynth starts, so initially we will have to make it. The simplest way is to run the following line, and the simplest way to run a line is to put point on the line and type C-cC-c (Hsc -> Expression -> Run line). > withSC3 reset Doing this is so common there is a keybinding for it, C-cC-k (Hsc -> SCSynth -> Reset scsynth). To make a test sound run the following: > audition (sinOsc AR 440 0 * 0.1) This ought to play a quiet sine oscillator at A440. To see the server status type C-cC-w (Hsc -> SCSynth -> Display status). To stop the sound reset the server, ie. type C-cC-k. For expressions that don't fit on one line select the region and type C-cC-e (Hsc -> Expression -> Run region). This writes the region in a do block in a main procedure to a temporary file [2], loads the file and then runs main. > let f = sinOsc AR (xLine KR 1 1000 9 RemoveSynth) 0 * 200 + 800 > audition (sinOsc AR f 0 * 0.1) (To select a region use the mouse or place point at one end, type C-Space and move point to the other end.) To find help on a UGen or on a SuperCollider server command put point over the identifier and type C-cC-h (Hsc -> Help -> Hsc help). This opens the help file, which ought to have working examples in it, the above graph is in the sinOsc help file. To stop ghci type C-cC-x (Hsc -> Haskell -> Quit haskell). It may have been a mistake to just use .lhs as the extension, however it is not a disaster because the Hsc mode is a derivative of the haskell mode. Perhaps it ought to be changed to .hsc. Hope this is clear-ish, please send through any questions, bug reports or patches! Regards, Rohan [1] To get this loaded I have the following in ~/.emacs: (push "~/ext/src/haskell/fptools/fptools/CONTRIB/haskell-modes/emacs" load-path) (load "haskell-site-file.el") (add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode) (add-hook 'haskell-mode-hook 'turn-on-haskell-indent) (add-hook 'haskell-mode-hook 'turn-on-haskell-ghci))) [2] The file is written to /tmp/hsc.lhs, the preamble imports the following modules, this is enough to run the help file examples. import Sound.OpenSoundControl import Sound.SC3 import Control.Monad import System.Random

1 0