- Haskell-Cafe - Haskell.org

Speed of simulation in Aivika
by David Sorokin 09 Jul '17

09 Jul '17

Hi Cafe, I’m glad to inform that the speed of simulation in the aivika [1] simulation library of version >= 5.2 has been dramatically increased after I started using the mwc-random [2] package for generating random numbers. It was possible to use custom random number generators before, but now the random number generator from the mentioned package is used by default. To improve the speed of simulation, in most cases it will be sufficient just to recompile your simulation models. In some my tests the speed of simulation has been increased up to 7 times when using default settings. The mwc-random package is just fantastic! Another good news is that I recently improved the distributed simulation module [3], which has recovering capabilities now in case of temporary connection errors. It should be quite unusual for the optimistic Time Warp method. In short, it means that we can build discrete event distributed simulation models using the ordinary Internet and cloud services. Best regards, David Sorokin [1] http://hackage.haskell.org/package/aivika [2] http://hackage.haskell.org/package/mwc-random [3] http://hackage.haskell.org/package/aivika-distributed

2 1

Haskell in Leipzig 2017: 2nd call for papers
by Wolfgang Jeltsch 07 Jul '17

07 Jul '17

Event: Haskell in Leipzig 2017 Time: October 26–28, 2017 Place: HTWK Leipzig, Germany Homepage: https://hal2017.softbase.org/ About ===== Haskell is a modern functional programming language that allows rapid development of robust and correct software. It is renowned for its expressive type system, its unique approaches to concurrency and parallelism, and its excellent refactoring capabilities. Haskell is both the playing field of cutting-edge programming language research and a reliable base for commercial software development. The workshop series Haskell in Leipzig (HaL), now in its 12th year, brings together Haskell developers, Haskell researchers, Haskell enthusiasts, and Haskell beginners to listen to talks, take part in tutorials, join in interesting conversations, and hack together. To support the latter, HaL will include a one-day hackathon this year. The workshop will have a focus on functional reactive programming (FRP) this time, while continuing to be open to all aspects of Haskell. As in the previous year, the workshop will be in English. Contributions ============= Everything related to Haskell is on topic, whether it is about current research, practical applications, interesting ideas off the beaten track, education, or art, and topics may extend to functional programming in general and its connections to other programming paradigms. Contributions can take the form of * talks (about 30 minutes), * tutorials (about 90 minutes), * demonstrations, artistic performances, or other extraordinary things. Please submit an abstract that describes the content and form of your presentation, the intended audience, and required previous knowledge. We recommend a length of 2 pages, so that the program committee and the audience get a good idea of your contribution, but this is not a hard requirement. Please submit your abstract as a PDF document at https://easychair.org/conferences/?conf=hal2017 until Friday, August 4, 2017. You will be notified by Friday, August 25, 2017. Hacking Projects ================ Projects for the hackathon can be presented during the workshop. A prior submission is not needed for this. Invited Speaker =============== * Ivan Perez, University of Nottingham, UK Program Committee ================= * Edward Amsden, Plow Technologies, USA * Heinrich Apfelmus, Germany * Jurriaan Hage, Utrecht University, The Netherlands * Petra Hofstedt, BTU Cottbus-Senftenberg, Germany * Wolfgang Jeltsch, Tallinn University of Technology, Estonia (chair) * Andres Löh, Well-Typed LLP, Germany * Keiko Nakata, SAP SE, Germany * Henrik Nilsson, University of Nottingham, UK * Ertuğrul Söylemez, Intelego GmbH, Germany * Henning Thielemann, Germany * Niki Vazou, University of Maryland, USA * Johannes Waldmann, HTWK Leipzig, Germany Questions ========= If you have any questions, please do not hesitate to contact Wolfgang Jeltsch at wolfgang-it(a)jeltsch.info.

1 0

"stack script" and extra-deps
by Patrick Pelletier 07 Jul '17

07 Jul '17

When I use "stack script", how can I specify a package which is not in Stackage? When using a stack.yaml, I can just specify such a package in extra-deps, but I'm not clear how to translate this to "stack script". Thanks, --Patrick

2 1

Prelude's documentation on Hackage incomplete?
by Benjamin Rickels 07 Jul '17

07 Jul '17

I was recently looking at the various functions the RealFrac <http://web.archive.org/web/20170702220651/https://hackage.haskell.org/packa…> type class provides and noticed, that Double <http://web.archive.org/web/20170702220651/https://hackage.haskell.org/packa…> isn't listed as an instance of it; and neither are Num, Real and Fractional mentioned as implemented instances in the documentation for Double. Now, somebody who is familiar with the hierarchy of the numeric type classes could of course rather easily deduct, that, since Double is an instance of RealFloat (this is mentioned in the documentation on Hackage), it is also required to implement all of the above. And (surely enough) the Haskell 98 Report <https://webcache.googleusercontent.com/search?q=cache:GKdvwWYGFLoJ:https://…> lists all the relevant implementations and so does a quick *:info Double* in GHCi. However I'd (assume and thus) argue, that most beginners who google (or especially hoogle) anything about Haskell, are often directed to the Hackage documentation itself - and any missing information there could lead to quite a bit of a headache; even more so, if this concerns something as important as the Prelude. Therefore I'd like to ask, whether this is a known issue and independently propose, that (in the meantime) an official recommendation somewhere to do a quick *:info <type class>* or :info *<type> *in GHCi yourself, as to find out, which type class instances are currently available, might help to alleviate some confusion. Benjamin

1 0

parallel Haskell
by Dennis Raddle 07 Jul '17

07 Jul '17

I have a program which does backtracking search in a recursive function. I followed the chapter in "Real World Haskell" to parallelize it. Without Control.Parallel, it uses about 25% of the CPU, namely one core out of four. With the suggestions in RWH it runs faster but still uses only 35% of the CPU max. So I set about creating a MWE in order to experiment and reach out for help. For some reason, my stripped down program isn't working with parallelism at all! There's no effect from the R.W.H. ideas. Can I get some suggestions as to why? Here's the program: -------------------------------------------- import qualified Data.List as L import Text.Printf import System.CPUTime import Data.Function import Control.Parallel -- Run backtracking search for a list of doubles, optimizing a -- fitness function on the list, called 'evalFunc'. At each step, use 'stepFunc' -- to generate a list of possible next Doubles that can be added to the list. -- We are done when the list has 'finalSize' elements. search1_par :: Int -> ([Double] -> Double) -> ([Double] -> [Double]) -> [Double] -> (Double,[Double]) search1_par finalSize evalFunc stepFunc listIn | length listIn == finalSize = (evalFunc listIn,listIn) | otherwise = let steps = stepFunc listIn (steps1,steps2) = divideListInTwo steps f s = search1_par finalSize evalFunc stepFunc $ s:listIn results1 = map f steps1 results2 = map f steps2 results = force results1 `par` (force results2 `pseq` (results1++results2)) in L.maximumBy (compare `on` fst) results force :: [a] -> () force xs = go xs `pseq` () where go (_:xs) = go xs go [] = 1 divideListInTwo :: [a] -> ([a],[a]) divideListInTwo [] = ([],[]) divideListInTwo xs = (take l xs,drop l xs) where l = length xs `div` 2 --------------------------------------------- -- some sample evaluation (fitness) functions and step generation functions. eval1 :: [Double] -> Double eval1 xs = v1 - v2 + v3 where v1 = sum $ zipWith (*) (cycle [1]) xs v2 = sum . map (*2) $ zipWith (*) (cycle [1,0]) xs v3 = sum . map (*3) $ zipWith (*) (cycle [1,0,0]) xs step1 :: [Double] -> [Double] step1 xs | l == 0 = take 8 $ xs | l == 1 = take 8 $ map (/2) xs | l == 2 = take 8 $ map (*3) xs where l = length xs `mod` 3 -------------------------------------------------------------------------------- -- main main = do t1 <- getCPUTime let f :: Double -> String f x = printf "%5.1f" x (_,result) = search1_par 13 eval1 step1 [1,2,3] putStrLn $ concatMap f result t2 <- getCPUTime putStrLn $ printf "CPU time: %.3f" ((fromIntegral $ t2-t1) / 1000000000000 :: Double)

3 6

Issue 61 :: Haskell Weekly
by Taylor Fausak 07 Jul '17

07 Jul '17

\ Haskell Weekly \/\/ Issue 62 <https://haskellweekly.news/issues/62.html> Welcome to another issue of Haskell Weekly! Haskell is a purely functional programming language that focuses on robustness, concision, and correctness. This is a weekly summary of what's going on in its community. ## Featured ## - YOW! Lambda Jam 2017 <https://www.youtube.com/playlist?list=PLIpl4GKFQR6dqCNb2J0eQFR21Lwnk4I86> Videos of 23 talks by Edward Kmett, John Hughes, Conal Elliott, Brian McKenna, Bodil Stokke, and others. - Perhaps not the answer you were expecting but you asked for it <https://personal.cis.strath.ac.uk/conor.mcbride/so-pigworker.pdf> A collection of Conor McBride's Stack Overflow answers. - Unit testing effectful Haskell with monad-mock <https://lexi-lambda.github.io/blog/2017/06/29/unit-testing-effectful-haskel…> > While monad-mock might not be anything drastically different from > existing testing techniques, my hope is that it can provide an > opinionated mechanism to make testing easy and accessible, even for > complex interactions with other services and systems. - Front Row is hiring a senior backend Haskell engineer (ad) <https://frontrow.workable.com/j/463B843754> > Come change how 6.5+ million K-12 US students learn Math, Language > Arts, Social Studies and more. Use data, advanced type systems, > great product design and deep pedagogy to change lives. - A major upgrade to Megaparsec: more speed, more power <https://markkarpov.com/post/megaparsec-more-speed-more-power.html> > The version 6 thus will aim to be not just a parser for human- > readable texts and source code, but "one size fits all" general > solution to parsing in Haskell, including low-level binary parsing. - Derive instances of representationally equal types <https://gist.github.com/Icelandjack/d258b88a0e0b3be2c0b3711fdd833045/fe806c…> > I made a way to get more free stuff and free stuff is good. - New version of FLTKHS with much better error messages and OpenGL integration <https://np.reddit.com/r/haskell/comments/6l85uj/announcement_new_version_of…> > Happy to announce a new major version of FLTKHS, the Haskell > binding to the FLTK for easy native cross-platform GUI apps in > Haskell. - Notes on fusion <http://teh.id.au/posts/2017/06/30/notes-on-fusion/index.html> > Fusion is one of those words that made me recoil for quite a few > years, since it sounds extremely complicated and arcane. A few > years into building applications in Haskell, I still hadn't forced > the thunk. - SuperRecord: Anonymous records for Haskell <https://www.athiemann.net/2017/07/02/superrecord.html> > A practical library for anonymous records that is both fast and has > an ergonomic interface for both using and extending it. - Typesafe modular arithmetic in Haskell <https://rkrishnan.org/posts/2017-06-20-typesafe-modulus-in-haskell.html> > We would like to get a type error (at compile time) if we do a > operation involving two numbers with a different modulus. The role > of a type system is to represent the invariants and so it will be > great to encode as many invariants of a particular value into the > type. - Lessons learned building a toy compiler <https://jaseemabid.github.io/2017/07/04/compiler.html> > We tend to think of compilers as big black boxes which transform > some high level language, let's say C into a binary in one big > step. I'd like to present it as a pipeline of languages and > transformations, each a bit simpler and slightly lower level than > the one before it. ## Package of the week ## This week's package of the week is Miso, a small isomorphic front-end framework. <https://hackage.haskell.org/package/miso-0.1.2.0> ## In brief ## - Diskhash: Disk-based, persistent hash tables <https://metarabbit.wordpress.com/2017/06/30/ann-diskhash-disk-based-persist…> - Graphing it out <https://mmhaskell.com/blog/2017/6/21/graphing-it-out> - highlight CLI application <https://functor.tokyo/blog/2017-07-01-highlight> - Idris dependent typing challenge: Bowling kata <https://deque.blog/2017/07/01/idris-bowling-kata/> - The Spiderman principle <https://www.snoyman.com/blog/2017/07/the-spiderman-principle> - What should a PostgreSQL migrator do? <https://medium.com/@jonathangfischoff/what-should-a-postgresql-migrator-do-…>

2 1

constraint inference
by Dmitry Olshansky 07 Jul '17

07 Jul '17

Hello, cafe! If we have many constraints then compiling is sometimes too slow. Especially if there are some type calculations. And I don't know how to divide this time among different source files because all constraints are checked only when we call a function. I tried to add constraint info into argument definition instead of the function signature but this trick is not working (see below). Is it (at least theoretically) possible to infer the constraint inside a function from the type of function's argument? ------------------------------------ $ stack ghci ---- GHCi, version 8.0.2: Prelude> import Data.Proxy Prelude Data.Proxy> import GHC.TypeLits Prelude Data.Proxy GHC.TypeLits> :set -XRankNTypes Prelude Data.Proxy GHC.TypeLits> let { f :: (KnownSymbol n => Proxy n) -> String; f = symbolVal } <interactive>:4:54: error: • No instance for (KnownSymbol n) arising from a use of ‘symbolVal’ Possible fix: add (KnownSymbol n) to the context of the type signature for: f :: (KnownSymbol n => Proxy n) -> String • In the expression: symbolVal In an equation for ‘f’: f = symbolVal ------------------------------------ Best regards, Dmitry

2 1

Re: [Haskell-cafe] representations of probability distributions
by David Banas 06 Jul '17

06 Jul '17

Hi Olaf, I can’t quite tell whether this is apropos to your request, but thought I’d mention it: https://wiki.haskell.org/Random_Processes <https://wiki.haskell.org/Random_Processes> -db

1 0

Re: [Haskell-cafe] representations of probability distributions
by Olaf Klinke 05 Jul '17

05 Jul '17

Thanks for the link, Benjamin. Can one give a Hasekll type to a particle filter? In the arxiv paper you linked, I found this quite unnerving sentence: "The divergence between the true conditioned distribution on execution traces and the distribution encoded by the program may depend strongly on what inference instructions are chosen and how they are interleaved with the incorporation of data." Does this mean: Here is a programming language that may or may not compute what you meant it to do? --Olaf

1 0

Instantiating a typeclass based on a runtime value?
by Saurabh Nanda 05 Jul '17

05 Jul '17

Overall context: I'm trying to port the DelayedJob library from Ruby/Rails world to Haskell. The basic idea is to serialise a job and write it to the DB, deserialise it, and run the job using a job-runner function, which is determined by the job-type. I'm using a type-class to define the custom job-runner, something on the lines of: class (FromJSON j, ToJSON j) => DelayedJob j where runJob :: j -> AppM () data SyncContactsJob = SyncContactsJob { userId :: UserId } deriving (Eq, Show, Generic, FromJSON, ToJSON) instance DelayedJob SyncContactsJob where runJob job = do -- entire job execution logic comes here Is there **any** type-system hackery, that will let me take a runtime value, eg. "SyncContactsJob", "DoBackupJob", and use that to run the correct version of the `runJob` function? That is, how do I write the following function: invokeJob :: JobId -> AppM () invokeJob jid = do jobRow <- fetchJob jid let jtype = jobRow ^. jobtype -- this will have "SyncContactsJob" jvalue = jobRow ^. jobdata -- this will have a Data.Aeson.Value runJob (......) -- QUESTION: What do I write here to make this compile?

3 2