- Glasgow-haskell-users

HEADS UP: Tickets have been triaged a bit
by Austin Seipp 23 Dec '14

23 Dec '14

Hi *, As many of you will probably notice, I have bulk modified a lot of Trac tickets and moved their milestone out. You might be wondering why; the reasoning is that since 7.10.1 RC1 is out (see other email), we need to start prioritizing what gets done. So, I moved all tickets that were a) set to 7.10.1 milestone, b) not closed, and c) had below 'high priority', to the 7.12.1 milestone. There are some tickets in 'normal' that probably should be moved back. If you're CC'd on a ticket and think it should be fixed for 7.10.1, please: - Set the milestone back to 7.10.1 - And if you can, take ownership! GHC HQ will probably only have time to organize efforts to take on the most high priority tickets - so any help you can offer is always appreciated. You can see the current list of tickets here. We'll put notes on the page at the top as time goes on to keep people up to date. https://ghc.haskell.org/trac/ghc/wiki/Status/GHC-7.10.1 -- Regards, Austin Seipp, Haskell Consultant Well-Typed LLP, http://www.well-typed.com/

1 0

ANN: deepseq-bounded, seqaid, leaky
by Andrew Seniuk 21 Dec '14

21 Dec '14

This trio of related packages explores strictness control in a variety of ways. deepseq-bounded provides classes and generic functions to artificially force evaluation, to extents controlled by static or dynamic configuration. seqaid puts that into practise, providing a GHC plugin to auto-instrument your package with a strictness harness, which is dynamically optimisable during runtime. This is supported directly in the GHC compilation pipeline, without requiring (or performing!) any edits to your sources. leaky is a minimal, prototypic executable that leaks space under current state-of-the-art compilation (GHC 7.8.3 -O2, at the present time). deepseq-bounded hackage: https://hackage.haskell.org/package/deepseq-bounded homepage: http://www.fremissant.net/deepseq-bounded seqaid hackage: https://hackage.haskell.org/package/seqaid homepage: http://www.fremissant.net/seqaid leaky hackage: https://hackage.haskell.org/package/leaky homepage: http://www.fremissant.net/leaky Reddit discussion for the three together: http://www.reddit.com/r/haskell/comments/2ps8f5/ann_deepseqbounded_seqaid_l… Easiest way to try them all, is to install seqaid and run the demo: cabal install seqaid seqaid demo This tests seqaid on a local copy of the leaky source package. It turned out to be routine to extend deepseq-bounded and seqaid to dynamically configurable parallelisation (paraid?). Many other wrappers could be explored, too! Maybe seqaid should be renamed to koolaid or something... It's a pretty complicated system, and just first release, so there's bound to be lots of problems. I've not set up a bug tracker, but will maintain a casual list of bugs and feature requests at http://www.fremissant.net/seqaid/trac and will set up a proper tracker if there's interest. Any isssues (or comments), I'm here, or on the reddit discussion (or email). Andrew Seniuk rasfar on #haskell

1 2

Proving properties of type-level natural numbers obtained from user input
by Bas van Dijk 19 Dec '14

19 Dec '14

Hi, I have another type-level programming related question: > {-# LANGUAGE GADTs #-} > {-# LANGUAGE TypeOperators #-} > {-# LANGUAGE ScopedTypeVariables #-} > {-# LANGUAGE KindSignatures #-} > > import GHC.TypeLits Say I have a Proxy p of some type-level natural number: > p :: forall (n :: Nat). Proxy n > p = Proxy Imagine I get p from user input like this: > main :: IO () > main = do > [arg] <- getArgs > let n = read arg :: Integer > > case someNatVal n of > Nothing -> error "Input is not a natural number!" > Just (SomeNat (p :: Proxy n)) -> ... I also have a function f which takes a proxy of a natural number but it has the additional constraint that the number should be lesser than or equal to 255: > f :: forall (n :: Nat). (n <= 255) => proxy n -> () > f _ = () How do I apply f to p? Obviously, applying it directly gives the type error: > f p <interactive>:179:1: Couldn't match expected type ‘'True’ with actual type ‘n0 <=? 255’ The type variable ‘n0’ is ambiguous In the expression: f p In an equation for ‘it’: it = f p I imagine I somehow need to construct some Proof object using a function g like: > g :: forall (n :: Nat). proxy n -> Proof > g _ = ... Where the Proof constructor encapsulates the (n <= 255) constraint: > data Proof where > NoProof :: Proof > Proof :: forall (n :: Nat). (n <= 255) > => Proxy n -> Proof With g in hand I can construct c which patterns matches on g p and when there's a Proof the (n <= 255) constraint will be in scope which allows applying f to p: > c :: () > c = case g p of > NoProof -> error "Input is bigger than 255!" > Proof p -> f p But how do I define g? Cheers, Bas

4 11

Behavior of touch#
by Brandon Simmons 16 Dec '14

16 Dec '14

The `primitive` package exports a lifted version of the undocumented `touch#` http://hackage.haskell.org/package/ghc-prim-0.3.1.0/docs/GHC-Prim.html which has type: touch :: PrimMonad m => a -> m () I'd like to know if this works correctly in general, or will it suffer from the same gotches w/r/t unboxing as with addFinalizer and Weak references? i.e. must it only be passed an unboxed type? Brandon

3 3

Re: ANNOUNCE: GHC 7.8.4 Release Candidate 1
by Mikolaj Konarski 13 Dec '14

13 Dec '14

OK. In that case, let's remember to get *that* version of cabal into 7.8.4. /me conditions himself with chocolate to help the remembering On Sat, Dec 13, 2014 at 11:02 PM, Thomas Tuegel <ttuegel(a)gmail.com> wrote: > On Sat, Dec 13, 2014 at 3:56 PM, Mikolaj Konarski > <mikolaj(a)well-typed.com> wrote: >> On Sat, Dec 13, 2014 at 8:53 PM, Carter Schonwald >> <carter.schonwald(a)gmail.com> wrote: >>> Thomas and I have found some bugs in HPC on OSX, and we're in the midst of >>> tracking those down, >> >> You mean these are regressions? If they are introduced >> in one of the non-blocker fixes in 7.8.4, we can probably >> just revert them. Anyway, thanks a lot for testing. > > Sorry, these are not regressions. It's really a bug in Cabal which > will be fixed in 1.22. When Carter wrote this, we thought the problem > was with the GHC side of HPC because of some very vague error > messages. > > -- > Thomas Tuegel >

1 0

ANNOUNCE: GHC 7.8.4 Release Candidate 1
by Austin Seipp 13 Dec '14

13 Dec '14

We are pleased to announce the first release candidate for GHC 7.8.4: https://downloads.haskell.org/~ghc/7.8.4-rc1/ This includes the source tarball and bindists for 64bit Linux. Binary builds for other platforms will be available shortly. These binaries and tarballs have an accompanying SHA256SUMS file signed by my GPG key id (0x3B58D86F). We plan to make the 7.8.4 release sometime in the next few weeks. Please test as much as possible; bugs are much cheaper if we find them before the release! -- Regards, Austin Seipp, Haskell Consultant Well-Typed LLP, http://www.well-typed.com/

7 6

confusing type error
by Evan Laforge 10 Dec '14

10 Dec '14

I recently got a confusing error msg, and reduced it to a small case: f1 :: Monad m => m Bool f1 = f2 0 0 'a' f2 :: Monad m => Int -> Float -> m Bool f2 = undefined >From this, it's clear that f2 is being given an extra Char argument it didn't ask for. However, the error msg (ghc 7.8.3) is: Couldn't match type ‘m Bool’ with ‘Bool’ Expected type: Char -> m Bool Actual type: Char -> Bool Relevant bindings include f1 :: m Bool (bound at Bug.hs:4:1) The function ‘f2’ is applied to three arguments, but its type ‘Int -> Float -> Char -> Bool’ has only three In the expression: f2 0 0 'a' In an equation for ‘f1’: f1 = f2 0 0 'a' The confusing part is that 'f2' was applied to three arguments, but it's type has only three. It includes the Char in expected and actual types, and implies that the type of 'f2' includes the Char. So I took quite a while to realize that the type of 'f2' in fact *didn't* expect a Char (and had an 'm'), so that the "but its type" is *not* in fact its declared type. I suppose it infers a type for 'f2' based on its use, and that then becomes the "actual" type, but it seems less confusing if it picked the declared type of 'f2' as its actual type. Perhaps this is working as intended, but it it is confusing! Especially the part about "expected three but got three". Ideally I'd like to see "too many arguments" or at least "expected (Char -> m Bool) but actually 'm Bool'". Actually I'd expect the other way: "expected 'm Bool' but got (Char -> m Bool)' but I think ghc has always done it backwards from how I expect. It looks like it's substituting (->) for 'm', so maybe it's one of those things where ((->) a) is also a monad.

6 9

Re: New implementation draft for -XStaticPointers
by John Wiegley 02 Dec '14

02 Dec '14

>>>>> Facundo Domínguez <facundo.dominguez(a)tweag.io> writes: > We are pleased to announce a new implementation draft of the > StaticPointers extension [1]. Very nice, thank you! John

2 1

Defining a custom newByteArray primop that uses calloc?
by Brandon Simmons 27 Nov '14

27 Nov '14

In my tests, using calloc from: https://hackage.haskell.org/package/missing-foreign-0.1.1/docs/Foreign-Mars… was about twice as fast as allocating and zeroing the same amount of memory with `newByteArray` + any of `copy/set/fillMutableByteArray` (all three were nearly identical). Is there a way I can reasonably define my own `newByteArray` that uses calloc? FWIW here are a couple of the benchmarks I'm working with in criterion: arrTestSet :: Int -> IO () arrTestSet len = do let eBytes = (P.sizeOf (undefined::Int))*len a <- P.newAlignedPinnedByteArray eBytes (P.alignment (undefined :: Int)) void $ P.setByteArray a 0 len (1::Int) arrTestCallocAndWrite :: Int -> IO () arrTestCallocAndWrite len = do ptr <- callocBytes (len*(P.sizeOf(undefined::Int))) :: IO (Ptr Int) pokeElemOff ptr 0 1 free ptr Thanks, Brandon

3 2

Type-level Replicate function
by Bas van Dijk 21 Nov '14

21 Nov '14

Hi, tl;dr How do I implement a type-level Replicate function that takes a (n :: Nat) and a type e and produces a type-level list of n e elements. The rest of my email gives some background on why I need this, how it's supposed to be used and my current erroneous implementation. I'm presenting it as a Haskell program: {-# LANGUAGE TypeOperators #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE GADTs #-} import GHC.TypeLits import Data.Type.Equality import Data.Type.Bool -- For work I'm implementing a binary protocol for -- communicating with some device. I need to be able to send -- a packet of orders to a device. -- -- An order is a list of addresses and command to send to -- these addresses. -- -- After sending the packets of orders the device should -- send back a packet of replies. The packet of replies -- should have a reply for each command send to each -- address. -- -- I would like to make the latter requirement apparent in -- the types so that when I send a packet of orders the type -- will tell me what packet of replies to expect. -- -- So I introduce the OrderPacket type which is -- parameterised with a type-level lists of commands: data OrderPacket (cmds :: [*]) where -- The empty packet: NoOrders :: OrderPacket '[] -- Extending an existing packet with an order. -- -- The (n :: Nat) in Order denotes the number of -- addresses to send the command to. Note that because I -- expect n command replies back I need to create a -- type-level list of n commands and prepend that to the -- existing commands: (:>) :: !(Order n command) -> !(OrderPacket commands) -> OrderPacket (Replicate n command :++: commands) -- As explained, an Order is a vector of addresses of length -- n paired with a command: data Order (n :: Nat) command where Order :: (Command command) => !(Addresses n) -> !command -> Order n command -- In my real implementation this class describes how to -- encode / decode commands: class Command command -- This is the typical Vector of length n type specialised -- to Address: data Addresses (n :: Nat) where Nil :: Addresses 0 (:*:) :: !Address -> !(Addresses n) -> Addresses (n+1) infixr 5 :*: type Address = Int -- Append two type-level lists. type family (rs1 :: [*]) :++: (rs2 :: [*]) :: [*] type instance '[] :++: rs2 = rs2 type instance (r ': rs1) :++: rs2 = r ': (rs1 :++: rs2) -- I'm currently using the following Replicate type-level -- function: type family Replicate (n :: Nat) r :: [*] type instance Replicate (n :: Nat) r = If (n == 0) '[] (r ': Replicate (n-1) r) -- However when I write some code like the following: isNull :: OrderPacket cmds -> Bool isNull NoOrders = True isNull (orderMsg :> orderMsgs) = False -- I get the following error: src/TypeLevelReplicate.hs:49:9: Type function application stack overflow; size = 201 Use -ftype-function-depth=N to increase stack size to N GHC.TypeLits.EqNat (((n-1)-1)-1)...) 0 ~ (((n-1)-1)-1)...) == 0) In the pattern: orderMsg :> orderMsgs In an equation for ‘isNull’: isNull (orderMsg :> orderMsgs) = True Failed, modules loaded: none. -- Note that when I adapt my code to use my own type-level -- inductive implementation of natural numbers like: data N = Z | S N type family Replicate (n :: N) r :: [*] type instance Replicate Z r = '[] type instance Replicate (S n) r = r ': Replicate n r -- I don't get the type function application stack overflow. Any hints on how to make this work with Nats from GHC.TypeLits? Thanks, Bas

2 2