October 2004 - Haskell

Succ Zeroth IOHCC Results http://www.scannedinavian.org/iohcc/succzeroth-2004/
by Shae Matijs Erisson 09 Oct '04

09 Oct '04

After a long delay, the Succ Zeroth IOHCC Results are online! http://www.scannedinavian.org/iohcc/succzeroth-2004/ The minimalistic results page links to three winning submissions of much entertainment. Winners by Category: Best overall entry UlfNorell with MetaSteganoGraphicObfuscation Best Abuse of Compiler Specific Features and Best Signature Sized Entry DonSteward with Crawl Most Useful submission JeremyGibbons with PiSpigot Thanks to everyone who entered! Please enter again next year! -- Shae Matijs Erisson - Programmer - http://www.ScannedInAvian.org/ "I will, as we say in rock 'n' roll, run until the wheels come off, because I love what I do." -- David Crosby

1 0

threading mutable state through callbacks
by Jules Bean 08 Oct '04

08 Oct '04

Hi, I've been playing with some haskell bindings which basically bind C procedures in the IO monad. To write 'interesting' programs, you often need to manage your own state in addition to the implicit IO state. I have been allocating references with newIORef and then passing them around all my functions. But having to thread a parameter through all your functions is inconvenient (and fragile). I can see the solution to this problem in layering a state monad over the IO monad, and I can just about grok the syntax I need to use StateT, with a nice encapsulated environment record type and nice selector functions to use with gets. Now of course I don't even need to use IORefs any more since I can be more explicit and precise about my state and how it's manipulated. (this is potential even a useful feature, since I can step back to earlier time points just by saving the state, etc.) Unfortunately, it's not going to work. It's not going to work because some of the procedures take callbacks, and the callbacks are values of type IO (). I can see two solutions to this: a) revert to using an IORef, and use lexical scoping to define my callbacks in a location such that the reference to the environment is in scope. This will work, but it's just not convenient to define all your functions inside another function so you can do a lexical scoping trick... b) write the callbacks as values of type StateT Env IO () and then use the following 'environment binder' bindEnv env s = do { x <- readIORef env ; s' <- execStateT s x; writeIORef env s'} when I pass them to a callback. (which works fine as long as I have used lexical scoping to make sure env is visible at the binding site) Is this the right approach? Is there a better one? From the library perspective, would it be cool if library callback routines, which currently have a type like addCallback :: IO() -> IO() could be given the type addCallback :: MonadIO() -> IO() So that they'll let you add callbacks for any monad layered over IO. Or doesn't this idea work? Jules

2 1

Lazy evaluation
by Amadeo Casas Cuadrado 08 Oct '04

08 Oct '04

Hello, Could anyone tell me where can i find a webpage or a paper about how lazy implementation is done is Haskell? Thanks a lot! --Ama

2 1

Re: threading mutable state through callbacks
by oleg＠pobox.com 08 Oct '04

08 Oct '04

Jules Bean wrote: > Unfortunately, it's not going to work. It's not going to work because > some of the procedures take callbacks, and the callbacks are values of > type IO (). I can see two solutions to this: > > a) revert to using an IORef, and use lexical scoping to define my > callbacks in a location such that the reference to the environment is > in scope. This will work, but it's just not convenient to define all > your functions inside another function so you can do a lexical scoping > trick... > > b) write the callbacks as values of type > > StateT Env IO () > > Is this the right approach? Is there a better one? Yes: implicit parameters and implicit configurations. The end user code is often identical in both of these approaches (but the latter may require a bit more preparation. OTH, implicit parameters are supported by the compiler whereas the latter is just a Haskell library). Both approaches are compared in Appendix A of the paper http://www.eecs.harvard.edu/~ccshan/prepose/prepose.pdf The example is writing JNI functions in Haskell. Incidentally, the example illustrates passing of the implicit state (JNIEnv pointer) _around_ the exception handler. The problem is that the function 'handle' has the type handle :: (Exception -> IO a) -> IO a -> IO a rather than handle :: (Exception -> MonadIO a) -> MonadIO a -> MonadIO a > revert to using an IORef, and use lexical scoping to define my > callbacks in a location such that the reference to the environment is > in scope. This will work, but it's just not convenient to define all > your functions inside another function so you can do a lexical scoping > trick... The stated motivation of the implicit configurations is precisely that: make it appear that the IORef is `lexically scoped' over all of its clients without putting all the clients inside one giant function. The master file for the paper http://www.eecs.harvard.edu/~ccshan/prepose/prepose.lhs is a literate Haskell code, which you can load into GHCi as it is. You can then run all of the examples in the paper. If you have trouble using implicit configurations, have a particular application in mind and can turn it into a self-contained example (by replacing various functions with stubs wherever possible: e.g., see the very end of prepose.lhs), you may want to let Ken and me know. I'll see what can be done.

2 1

Random selection
by ldou 07 Oct '04

07 Oct '04

I have a string,e.g. "1245670398", now I want to select two element from the string randomly, and the two element must be different, how can I do?

3 2

different element
by ldou 06 Oct '04

06 Oct '04

In the random selection, it perhaps select the same element of the string, how can I select two different elements?

2 1

RE: [Haskell] Building from source
by Simon Marlow 06 Oct '04

06 Oct '04

On 06 October 2004 10:10, Christian Maeder wrote: > after checking out fptools from cvs. The simple sequence > > $ autoreconf > $ ./configure > $ make > > failed in the directory hood, because the target boot is unknown > there. Could/Should this be fixed? > > I know how to use mk/build.mk and the ProjectsToBuild variable. I > don't need hood, but make still should not fail (after ./configure). If you don't want to build hood, then remove it from the tree. Did you perhaps check out *everything*? The right way is to check out fpconfig first, and then each of the projects you're interested in separately, eg. for GHC you would check out ghc, libraries, and hslibs. The section on CVS in the building guide has more info: http://www.haskell.org/ghc/docs/latest/html/building/sec-cvs.html Cheers, Simon

2 1

How to get different two random numbers
by ldou 06 Oct '04

06 Oct '04

How to get different two random numbers, and use the two numbers in program,e.g x = b + c where b && c are different random numbers between 1..n

2 1

RE: [Haskell] GHC / Hugs Disagree on Constraints
by Simon Peyton-Jones 04 Oct '04

04 Oct '04

Hugs does support scoped type variables bound by *type sigs in patterns*, but not by class or instance declarations. So when you say (maxBound :: b) you are really saying (maxBound :: forall b. b) and it's that universal quantification that has no Bounded b context. That's why you need -fglasgow-exts to compile it with GHC, to get the scoped type variables. I've gotten so used to scoped type variables that I couldn't see why it wasn't Haskell 98, until I tried to compile without -fglasgow-exts. Then GHC says Key.hs:99: Could not deduce (Bounded b) from the context () arising from use of `maxBound' at Key.hs:99 Probable fix: Add (Bounded b) to the expected type of an expression When checking the type signature of the expression: maxBound :: forall b. b which does at least point to the error. Simon | -----Original Message----- | From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On Behalf Of Dominic | Steinitz | Sent: 02 October 2004 12:04 | To: haskell(a)haskell.org | Subject: [Haskell] GHC / Hugs Disagree on Constraints | | GHC accepts this with -fglasgow-exts | | instance (Ord a, Bits a, Bounded a, Integral a, LargeWord a, | Bits b, Bounded b, Integral b, LargeWord b) => | Bounded (LargeKey a b) where | minBound = 0 | maxBound = | fromIntegral $ | (1 + fromIntegral (maxBound::b))* | (1 + fromIntegral (maxBound::a)) - 1 | | Hugs rejects it with +N -98 with | | ERROR "Codec/Encryption/LargeKey.hs":94 - Cannot justify constraints in | type annotation | *** Expression : maxBound | *** Type : b | *** Given context : () | *** Constraints : Bounded b | | Since I've already declared b to be Bounded, it looks like a bug in Hugs. | | Dominic. | | =============================================================== | ======== | | module Codec.Encryption.LargeKey | (Word128,Word192,Word256,LargeWord) where | | import Data.Word | import Data.Bits | import Numeric | import Char | | -- Keys have certain capabilities. | | class LargeWord a where | largeWordToInteger :: a -> Integer | integerToLargeWord :: Integer -> a | largeWordPlus :: a -> a -> a | largeWordAnd :: a -> a -> a | largeWordOr :: a -> a -> a | largeWordShift :: a -> Int -> a | largeWordXor :: a -> a -> a | largeBitSize :: a -> Int | | -- Word64 is a key in the obvious way. | | instance LargeWord Word64 where | largeWordToInteger = toInteger | integerToLargeWord = fromInteger | largeWordPlus = (+) | largeWordAnd = (.&.) | largeWordOr = (.|.) | largeWordShift = shift | largeWordXor = xor | largeBitSize = bitSize | | -- Define larger keys from smaller ones. | | data LargeKey a b = LargeKey a b | deriving (Eq, Ord) | | instance (Ord a, Bits a, LargeWord a, Bits b, LargeWord b) => | LargeWord (LargeKey a b) where | largeWordToInteger (LargeKey lo hi) = | largeWordToInteger lo + (2^(bitSize lo)) * largeWordToInteger hi | integerToLargeWord x = | let (h,l) = x `quotRem` (2^(bitSize lo)) | (lo,hi) = (integerToLargeWord l, integerToLargeWord h) in | LargeKey lo hi | largeWordPlus (LargeKey alo ahi) (LargeKey blo bhi) = | LargeKey lo' hi' where | lo' = alo + blo | hi' = ahi + bhi + if lo' < alo then 1 else 0 | largeWordAnd (LargeKey alo ahi) (LargeKey blo bhi) = | LargeKey lo' hi' where | lo' = alo .&. blo | hi' = ahi .&. bhi | largeWordOr (LargeKey alo ahi) (LargeKey blo bhi) = | LargeKey lo' hi' where | lo' = alo .|. blo | hi' = ahi .|. bhi | largeWordOr (LargeKey alo ahi) (LargeKey blo bhi) = | LargeKey lo' hi' where | lo' = alo .|. blo | hi' = ahi .|. bhi | largeWordXor (LargeKey alo ahi) (LargeKey blo bhi) = | LargeKey lo' hi' where | lo' = alo `xor` blo | hi' = ahi `xor` bhi | largeWordShift w 0 = w | largeWordShift (LargeKey lo hi) x = | if bitSize lo < bitSize hi | then LargeKey (shift lo x) | (shift hi x .|. (shift (conv lo) (x - | (bitSize lo)))) | else LargeKey (shift lo x) | (shift hi x .|. (conv $ shift lo (x - | (bitSize lo)))) | where conv = integerToLargeWord . largeWordToInteger | largeBitSize ~(LargeKey lo hi) = largeBitSize lo + largeBitSize hi | | instance (Ord a, Bits a, LargeWord a, Bits b, LargeWord b) => Show | (LargeKey a b) where | showsPrec p = showInt . largeWordToInteger | | instance (Ord a, Bits a, LargeWord a, Bits b, LargeWord b) => | Num (LargeKey a b) where | (+) = largeWordPlus | fromInteger = integerToLargeWord | | -- Larger keys are instances of Bits provided their constituents are keys. | | instance (Ord a, Bits a, LargeWord a, Bits b, LargeWord b) => | Bits (LargeKey a b) where | (.&.) = largeWordAnd | (.|.) = largeWordOr | xor = largeWordXor | shift = largeWordShift | bitSize = largeBitSize | | instance (Ord a, Bits a, Bounded a, Integral a, LargeWord a, | Bits b, Bounded b, Integral b, LargeWord b) => | Bounded (LargeKey a b) where | minBound = 0 | maxBound = | fromIntegral $ | (1 + fromIntegral (maxBound::b))* | (1 + fromIntegral (maxBound::a)) - 1 | | instance (Ord a, Bits a, LargeWord a, Ord b, Bits b, LargeWord b) => | Integral (LargeKey a b) where | toInteger = largeWordToInteger | | instance (Ord a, Bits a, LargeWord a, Ord b, Bits b, LargeWord b) => | Real (LargeKey a b) | | instance Enum (LargeKey a b) | | type Word96 = LargeKey Word32 Word64 | type Word128 = LargeKey Word64 Word64 | type Word160 = LargeKey Word32 Word128 | type Word192 = LargeKey Word64 Word128 | type Word224 = LargeKey Word32 Word192 | type Word256 = LargeKey Word64 Word192 | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell

2 1

QuickCheck
by Dominic Steinitz 02 Oct '04

02 Oct '04

Can someone remind me how to change the number of tests that QuickCheck performs? I'm sure I knew how to do this but I can't find it in the documentation and a web search revealed no examples. Thanks, Dominic.

1 0