- Haskell-Cafe - Haskell.org

Defining a Strict language pragma
by Johan Tibell 06 Nov '12

06 Nov '12

Hi all, I would like to experiment with writing some modules (e.g. low-level modules that do a lot of bit twiddling) in a strict subset of Haskell. The idea is to remove boilerplate bangs (!) and instead declare the whole module strict. I believe this would both make code that needs to be strict more declarative (you say what you want once, instead of putting bangs everywhere), less noisy, and more predictable (no need to reason about laziness in places where you know you don't want it). The idea is to introduce a new language pragma {-# LANGUAGE Strict #-} that has the above described effect. The tricky part is to define the semantics of this pragma in terms of Haskell, instead of in terms of Core. While we also need the latter, we cannot describe the feature to users in terms of Core. The hard part is to precisely define the semantics, especially in the presence of separate compilation (i.e. we might import lazy functions). I'd like to get the Haskell communities input on this. Here's a strawman: * Every function application f _|_ = _|_, if f is defined in this module [1]. This also applies to data type constructors (i.e. the code acts if all fields are preceded by a bang). * lets and where clauses act like (strict) case statements. * It's still possible to define strict arguments, using "~". In essence the Haskell lazy-by-default with opt-out via "!" is replaced with strict-by-default with opt-out via "~". Thoughts? Cheers, Johan 1. I could see the very opposite choice be made: function applications to functions defined in other modules are also strict. We should try to think about the implications of either policy.

5 5

Announce: Haskell Platform 2012.4.0.0
by Mark Lentczner 06 Nov '12

06 Nov '12

I'm pleased to announce that Haskell Platform 2012.4.0.0<http://www.haskell.org/platform/index.html#2012.4.0.0>is now available. This release contains three new packages to the platform: - async-2.0.1.3<http://lambda.haskell.org/platform/doc/current/packages/async-2.0.1.3/doc/h…> - split-0.2.1.1<http://lambda.haskell.org/platform/doc/current/packages/split-0.2.1.1/doc/h…> - vector-0.10.0.1<http://vector-0.10.0.1http://lambda.haskell.org/platform/doc/current/packag…> The remainder of the changes are small updates to the versions of GHC (now 7.4.2) and several other packages. Installers for Windows <http://www.haskell.org/platform/windows.html>, Mac OS X <http://www.haskell.org/platform/mac.html>, and the source tar ball<http://www.haskell.org/platform/linux.html>are all now available from the site. Linux distribution packages should be available shortly. On behalf of the Haskell Platform team<http://trac.haskell.org/haskell-platform/wiki/Members> , - Mark "mzero" Lentczner, Release Manager

4 4

Call for discussion: OverloadedLists extension
by Michael Snoyman 06 Nov '12

06 Nov '12

(Prettier formatting available at: https://gist.github.com/3761252) Many of us use the OverloadedStrings language extension on a regular basis. It provides the ability to keep the ease-of-use of string literal syntax, while getting the performance and correctness advantages of specialized datatypes like ByteString and Text. I think we can get the same kind of benefit by allowing another literal syntax to be overloaded, namely lists. ## Overly simple approach The simplest example I can think of is allowing easier usage of Vector: [1, 2, 3] :: Vector Int In order to allow this, we could use a typeclass approach similar to how OverloadedStrings works: class IsList a where fromList :: [b] -> a b instance IsList Vector where fromList = V.fromList foo :: Vector Int foo = fromList [1, 2, 3] ## Flaws However, such a proposal does not allow for constraints, e.g.: instance IsList Set where fromList = Set.fromList No instance for (Ord b) arising from a use of `Set.fromList' In the expression: Set.fromList In an equation for `fromList': fromList = Set.fromList In the instance declaration for `IsList Set' Additionally, it provides for no means of creating instances for datatypes like Map, where the contained value is not identical to the value contained in the original list. In other words, what I'd like to see is: [("foo", 1), ("bar", 2)] :: Map Text Int ## A little better: MPTC A simplistic approach to solve this would be to just use MultiParamTypeClasses: class IsList input output where fromList :: [input] -> output instance IsList a (Vector a) where fromList = V.fromList foo :: Vector Int foo = fromList [1, 2, 3] Unfortunately, this will fail due to too much polymorphism: No instance for (IsList input0 (Vector Int)) arising from a use of `fromList' Possible fix: add an instance declaration for (IsList input0 (Vector Int)) In the expression: fromList [1, 2, 3] In an equation for `foo': foo = fromList [1, 2, 3] This can be worked around by giving an explicit type signature on the numbers in the list, but that's not a robust solution. In order to solve this properly, I think we need either functional dependencies or type families: ## Functional dependencies class IsList input output | output -> input where fromList :: [input] -> output instance IsList a (Vector a) where fromList = V.fromList instance Ord a => IsList a (Set a) where fromList = Set.fromList instance Ord k => IsList (k, v) (Map k v) where fromList = Map.fromList foo :: Vector Int foo = fromList [1, 2, 3] bar :: Set Int bar = fromList [1, 2, 3] baz :: Map String Int baz = fromList [("foo", 1), ("bar", 2)] ## Type families class IsList a where type IsListInput a fromList :: [IsListInput a] -> a instance IsList (Vector a) where type IsListInput (Vector a) = a fromList = V.fromList instance Ord a => IsList (Set a) where type IsListInput (Set a) = a fromList = Set.fromList instance Ord k => IsList (Map k v) where type IsListInput (Map k v) = (k, v) fromList = Map.fromList foo :: Vector Int foo = fromList [1, 2, 3] bar :: Set Int bar = fromList [1, 2, 3] baz :: Map String Int baz = fromList [("foo", 1), ("bar", 2)] ## Conclusion Consider most of this proposal to be a strawman: names and techniques are completely up to debate. I'm fairly certain that our only two choices to implement this extension is a useful way is fundeps and type families, but perhaps there's another approach I'm missing. I don't have any particular recommendation here, except to say that fundeps is likely more well supported by other compilers.

10 19

Is XMonad still developed or with a current maintainer?
by Alfredo Di Napoli 06 Nov '12

06 Nov '12

Hi guys, looking at the Darcs repo it seems that something is happening, but XMonad wasn't updated in a year on Hackage and everything seems to be still. Is XMonad still actively developed? If yes, who is the current maintainer? It would be good to have him listed in the Hackage package description, in order to contact him. Atm there is one generic email that seems not to be read very often :) Cheers, A.

4 10

ANNOUNCE: vim-hs-module-name
by Roman Cheplyaka 06 Nov '12

06 Nov '12

vim-hs-module-name is a Vim plugin that infers and inserts the Haskell module name. Please see the github page for details: https://github.com/feuerbach/vim-hs-module-name Roman

1 0

more sharing in generated code
by Peter Divianszky 06 Nov '12

06 Nov '12

Hi Joachim, > > ... > > I think one problem with this approach is that now, until "x r'" is > evaluated, you keep both r and r' alive. If r was _not_ retained by > anything else, then you are now preventing the GC from freeing it and > hence increasing the memory footprint. Good remark, this can be solved with weak pointers, although I don't know how efficient they are. ---------------------- The next version of the proposal Replace every record update r' = r { x = y } with r' = r { x = update (weak r) r' (x r) y) } in generated code if some sharing aware optimization flag is enabled. Auxilary functions: weak :: a -> Weak a -- make a weak pointer which is not followed by GC update :: Weak r -> r -> x -> x update r_old r_new x_old x_new = unsafePerformIO $ do eval x_new b <- x_old === x_new when b (replace r_new r_old) return x_new (===) :: a -> a -> IO Bool -- pointer-equality for boxed values, equality for unboxed values replace :: a -> Weak a -> IO () -- replace thunks in the heap -- do nothing if the weak pointer was gone Cheers, Peter

2 1

Re: [Haskell-cafe] Partial application in case expression rules
by Patrick Premont 05 Nov '12

05 Nov '12

I had not thought of this record syntax. But it does not perform the currying effect shown in the example; it just drops the omitted fields. Brandon Allbery <allbery.b(a)gmail.com> wrote: >On Mon, Nov 5, 2012 at 4:15 PM, Stephen Tetley <stephen.tetley(a)gmail.com>wrote: > >> There is a long extant GHC extension to elide constructor arguments >> >f (Leaf {}) = ... >> f (Node {}) = ... >> > >I don't think that's an extension, it falls out directly from how Haskell >builds records on top of ADTs and is specified in the standard as such. > See http://www.haskell.org/onlinereport/decls.html at the end of the >"Labelled Fields" section for Haskell98, or the middle of section 3.15.2 in >http://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-490003.1… >the H'2010 version. > >-- >brandon s allbery kf8nh sine nomine associates >allbery.b(a)gmail.com ballbery(a)sinenomine.net >unix/linux, openafs, kerberos, infrastructure http://sinenomine.net

1 0

[ANNOUNCE] network-bitcoin
by Clark Gaebel 05 Nov '12

05 Nov '12

Hello Cafe, You've heard of the neat crypto-currency bitcoin[1], haven't you? Well, I've just released network-bitcoin[2] which provides Haskell bindings to the bitcoin daemon. Hopefully, this will make your bitcoin-related goals easier to achieve. Who knows, it might even make bitcoin integration for the various web frameworks a bit easier. Special thanks to Michael Hendricks who wrote the original version of network-bitcoin, which I used as a base for this release. Regards, - Clark [1] http://bitcoin.org [2] http://hackage.haskell.org/package/network-bitcoin-1.0.1

2 1

Partial application in case expression rules
by Patrick Premont 05 Nov '12

05 Nov '12

Occasionally I find it would be nice to be able to omit some or all constructor parameters from a pattern matching rule. Perhaps the compiler could put them in for you and apply them to the right hand side of the rule ? data Tree a = Leaf a| Node (Tree a) (Tree a) treeFold :: (a -> a -> a) -> Tree a -> a treeFold f = \case Leaf -> id Node -> f `on` treeFold f This could be desugared at some point to treeFold f = \case Leaf a -> id a Node a b -> (f `on` treeFold f) a b I suppose such an extension has been considered before, but I could not find such a discussion. (In http://haskell.1045720.n5.nabble.com/Partial-pattern-matching-td3087200.html the thread focused instead on case expressions over functions) Any pointers to previous discussions ? Comments ? Thank you! Patrick Prémont

3 3

How to handle exceptions in conduit?
by Hiromi ISHII 05 Nov '12

05 Nov '12

Hi, there I'm writing a program communicating with external process, which can be sometimes fail, using conduit and process-conduit package. Consider the following example, which reads paths from the config file, and passes their contents to external process, and output the results: ```exc.hs module Main where import qualified Data.ByteString.Char8 as BS import Data.Conduit import qualified Data.Conduit.Binary as BC import qualified Data.Conduit.List as LC import Data.Conduit.Process main :: IO () main = runResourceT $ BC.sourceFile "paths.dat" $$ BC.lines =$= myConduit =$= LC.mapM_ (unsafeLiftIO . BS.putStrLn) myConduit :: MonadResource m => Conduit BS.ByteString m BS.ByteString myConduit = awaitForever $ \path -> BC.sourceFile (BS.unpack path) =$= conduitCmd "./sometimes-fail" ``` ```sometimes-fail.hs module Main where import System.Random main :: IO () main = do b <- randomRIO (1,10 :: Int) if b < 9 then interact id else error "error!" ``` ```paths.dat txt/a.dat txt/b.dat txt/c.dat ...bra, bra, bra... ``` As you can see, `sometimes-fail` is a simple echoing program, but sometimes fail at random. Successful result is below: ``` $ ./exc this is a! this is b! this is c! this was d! this was e! and this is f. ``` but if `sometimes-fail` fails in some place, `exc` exits with exception like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! ``` But I want to write the program acts like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! this was e! and this is f. ``` that is, ignore the exception and continue to process remaining streams. So, the question is: how to handle the exception in `myConduit` and proceed to remaining works? In `conduit` package, `Pipe` type is not an instance of `MonadBaseControl IO` so it cannot handle exceptions within it. I think this is necessary to make `ResourceT` release resources correctly. So, how to write the Conduit that ignores some kind of exceptions and proceed to remaining works? One sometimes want to ignore the invalid input and/or output and just continue to process the remaining stream. One solution is that libraries using conduit provide "failure-ignore" version for all the `Pipe`s included in the library, but I think it is too heavy solution. It is ideal that `conduit` can package provides combinator that makes exsiting `Pipe`s "failure-ignore". -- Hiromi ISHII konn.jinro(a)gmail.com

2 4