- Haskell-Cafe - Haskell.org

Access violation when stack haddock haskell-src-exts since LTS 12.0
by Yuji Yamamoto 23 Aug '18

23 Aug '18

I always get an " Access violation in generated code when reading 0x28900000" error when executing > stack haddock haskell-src-exts since LTS 12.0. I'm not sure to which project I should submit a bug report. GHC? Haddock? Or Stack? And how can I make a smaller case to reproduce the same error? I attached a log when executing with --verbose --cabal-verbose for your info. -- 山本悠滋 twitter: @igrep GitHub: https://github.com/igrep GitLab: https://gitlab.com/igrep Facebook: http://www.facebook.com/igrep Google+: https://plus.google.com/u/0/+YujiYamamoto_igrep

8 11

ANN: leancheck-v0.7.2, enumerative QuickCheck-like testing
by Rudy Matela 22 Aug '18

22 Aug '18

Hello Haskell-Café, LeanCheck is a simple enumerative property-based testing library for Haskell. It is highly portable, and even works on Hugs98 (v2006-09). It does not pull any dependencies other than what's bundled with GHC. Check it out on Hackage and GitHub: https://hackage.haskell.org/package/leancheck https://github.com/rudymatela/leancheck A simple example follows: > import Test.LeanCheck > import Data.List (sort, union) > check $ \xs -> sort (sort xs) == sort (xs::[Int]) +++ OK, passed 200 tests. > check $ \xs ys -> xs `union` ys == ys `union` (xs::[Int]) *** Failed! Falsifiable (after 4 tests): [] [0,0] LeanCheck works on all types that are instances of the Listable typeclass. A TH automatic deriver is provided with LeanCheck so you don't need to learn LeanCheck's DSL to test with your types. I recently released 0.7.2, there are several additions since last announcement here. Notable changes include: * minor fixes for loading on Hugs98; * functions to compute statistics about generated values; and * a family of functions to test invariants of typeclass instances: > data MyTy = ... > instance ... MyTy where ... > import Test.LeanCheck.Utils > check $ (okEqOrd :: MyTy -> MyTy -> MyTy -> Bool) +++ OK, passed 200 tests. > check $ (okNum :: MyTy -> MyTy -> MyTy -> Bool) +++ OK, passed 200 tests. LeanCheck is available on Hackage or Stackage, and can be installed using: $ cabal install leancheck As far as I am aware, there are no bindings to use LeanCheck with tasty, test-framework or hspec yet, but contributions are welcome. I may create bindings for those if I ever get the time. Best Regards, Rudy

1 0

how do FFI calls show up in profiling info?
by Johannes Waldmann 22 Aug '18

22 Aug '18

Dear Cafe, how would FFI calls show up in profiles? I am using hmatrix-glpk. The relevant FFI call is in https://hackage.haskell.org/package/hmatrix-glpk-0.19.0.0/docs/src/Numeric.… I am compiling with profiling (for executables and libraries), and I am running with +RTS -P . The .prof file does not contain c_simplex_sparse (the C function) It does mention simplexSparse (the Haskell function that calls it) but with a suspiciously low time. - J.W.

2 1

DSLDI 2018: Extended Call for Talk Proposals
by Sam Tobin-Hochstadt 21 Aug '18

21 Aug '18

We've extended the deadline for DSLDI talk proposals until the 24th. ********************************************************************* EXTENDED CALL FOR TALK PROPOSALS DSLDI 2018 Sixth Workshop on Domain-Specific Language Design and Implementation November 6th, 2018 Boston, USA Co-located with SPLASH http://2018.splashcon.org/track/dsldi-2018-talks https://twitter.com/wsdsldi ********************************************************************* Deadline for talk proposals: 24th of August, 2018, AoE Well-designed and implemented domain-specific languages (DSLs) can achieve both usability and performance benefits over general-purpose programming languages. By raising the level of abstraction and exploiting domain knowledge, DSLs can make programming more accessible, increase programmer productivity, and support domain-specific optimizations. ## Workshop Goal Domain-Specific Language Design and Implementation (DSLDI) is a workshop intended to bring together researchers and practitioners interested in discussing how DSLs should be designed, implemented, supported by tools, and applied in realistic contexts. The focus of the workshop is on all aspects of this process, from soliciting domain knowledge from experts, through the design and implementation of the language, to evaluating whether and how a DSL is successful. More generally, we are interested in continuing to build a community that can drive forward the development of modern DSLs. ## Workshop Format DSLDI is a single-day workshop and will consist of an invited speaker followed by moderated audience discussions structured around a series of short talks. The role of the talks is to facilitate interesting and substantive discussion. Therefore, we welcome and encourage talks that express strong opinions, describe open problems, propose new research directions, and report on early research in progress. Proposed talks should be on topics within DSLDI’s area of interest, which include but are not limited to: * solicitation and representation of domain knowledge * DSL design principles and processes * DSL implementation techniques and language workbenches * domain-specific optimizations * human factors of DSLs * tool support for DSL users * community and educational support for DSL users * applications of DSLs to existing and emerging domains * studies of usability, performance, or other benefits of DSLs * experience reports of DSLs deployed in practice ## Call for Talk Proposals We solicit talk proposals in the form of short abstracts (max. 2 pages). A good talk proposal describes an interesting position, open problem, demonstration, or early achievement. The submissions will be reviewed on relevance and clarity, and used to plan the mostly interactive sessions of the workshop day. Publication of accepted abstracts and slides on the website is voluntary. * Deadline for talk proposals: August 17th, 2018 * Notification: September 17th, 2018 * Workshop: November 6th, 2018 * Submission website: https://dsldi18.hotcrp.com/ ## Workshop Organization Co-chairs: * Sam Tobin-Hochstadt (samth(a)indiana.edu) Indiana University * Lindsey Kuper (lindsey(a)composition.al) University of California, Santa Cruz Follow us on Twitter at https://twitter.com/wsdsldi Program committee: * Eric Van Wyk (University of Minnesota) * Katherine Ye (Carnegie Mellon University) * Nate Foster (Cornell University) * Spencer Florence (Northwestern University) * Phitchaya Mangpo Phothilimthana (University of California, Berkeley) * Jeremy Gibbons (University of Oxford) * Edwin Brady (University of St. Andrews)

1 0

Six new assistant/associate professor positions in Nottingham
by Graham Hutton 21 Aug '18

21 Aug '18

Dear all, The School of Computer Science at the University of Nottingham is seeking to make multiple new appointments (potentially up to 6) at the Assistant or Associate Professor level: https://www.nottingham.ac.uk/jobs/currentvacancies/ref/SCI190718 Applications in the area of the Functional Programming (FP) lab would be most welcome. The FP lab is keen to receive applications from candidates with an excellent publication record and the ability to secure external funding to support their research. Further information about the FP lab is available from: https://www.nottingham.ac.uk/research/groups/fp-lab/ The deadline for applications is 30th September 2018. The advert mentions some specific research areas, but the positions are open to applicants from any area of Computer Science. Best wishes, Graham Hutton — Professor Graham Hutton School of Computer Science University of Nottingham, UK http://www.cs.nott.ac.uk/~pszgmh This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law.

1 0

Re: [Haskell-cafe] Is there a library that has a strict version of `sum`?
by Damian Nadales 19 Aug '18

19 Aug '18

Ok, so if understood the bottom line of the answers I got from Vanessa and Hiromi the take away seems to be: if you're prototyping then stick to the lazy version of sum, otherwise use more advanced data structures (Vectors or Folds). On Tue, Aug 14, 2018 at 5:18 PM Vanessa McHale <vanessa.mchale(a)iohk.io> wrote: > Actually, vector has a sum function already: > http://hackage.haskell.org/package/vector-0.12.0.1/docs/Data-Vector.html#v:… > > It's strict, and I'd guess more efficient than foldl' on lists. > > On 08/14/2018 09:44 AM, Vanessa McHale wrote: > > To be more explicit: unless you've actually benchmarked sum vs sum' this > seems to be a premature optimization and you'd be better off just using the > stock sum with a sensible data structure. > > On 08/14/2018 09:40 AM, Damian Nadales wrote: > > > > On Tue, Aug 14, 2018 at 4:25 PM Vanessa McHale <vanessa.mchale(a)iohk.io> > wrote: > >> If you'd rather import a custom prelude instead of writing `sum = foldl' >> (+) 0` you might want to think about how dependencies affect maintaining a >> package. >> >> What's the actual problem you're trying to solve? >> > Just add a list of values. I was expecting such a function to be already > defined somewhere else. > > Personally, in terms of cognitive complexity I find `sum` less complex > than `fold' (+) 0`... > > >> >> On 08/14/2018 04:09 AM, Damian Nadales wrote: >> >> I thought the answer would be easy to find on the internet, but I cannot >> find any package that features a strict version of `sum`. >> >> Do you know if such a function is defined anywhere? (like a custom >> prelude for instance) >> >> I know it is trivial to define, but I would prefer not to repeat myself >> (and somebody else). >> >> Thanks! >> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> To (un)subscribe, modify options or view archives go to:http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> Only members subscribed via the mailman list are allowed to post. >> >> _______________________________________________ >> Haskell-Cafe mailing list >> To (un)subscribe, modify options or view archives go to: >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> Only members subscribed via the mailman list are allowed to post. > > > -- > > > > *Vanessa McHale* > Functional Compiler Engineer | Chicago, IL > > Website: www.iohk.io <http://iohk.io> > Twitter: @vamchale > PGP Key ID: 4209B7B5 > > [image: Input Output] <http://iohk.io> > > [image: Twitter] <https://twitter.com/InputOutputHK> [image: Github] > <https://github.com/input-output-hk> [image: LinkedIn] > <https://www.linkedin.com/company/input-output-global> > > > This e-mail and any file transmitted with it are confidential and intended > solely for the use of the recipient(s) to whom it is addressed. > Dissemination, distribution, and/or copying of the transmission by anyone > other than the intended recipient(s) is prohibited. If you have received > this transmission in error please notify IOHK immediately and delete it > from your system. E-mail transmissions cannot be guaranteed to be secure or > error free. We do not accept liability for any loss, damage, or error > arising from this transmission > > > -- > > > > *Vanessa McHale* > Functional Compiler Engineer | Chicago, IL > > Website: www.iohk.io <http://iohk.io> > Twitter: @vamchale > PGP Key ID: 4209B7B5 > > [image: Input Output] <http://iohk.io> > > [image: Twitter] <https://twitter.com/InputOutputHK> [image: Github] > <https://github.com/input-output-hk> [image: LinkedIn] > <https://www.linkedin.com/company/input-output-global> > > > This e-mail and any file transmitted with it are confidential and intended > solely for the use of the recipient(s) to whom it is addressed. > Dissemination, distribution, and/or copying of the transmission by anyone > other than the intended recipient(s) is prohibited. If you have received > this transmission in error please notify IOHK immediately and delete it > from your system. E-mail transmissions cannot be guaranteed to be secure or > error free. We do not accept liability for any loss, damage, or error > arising from this transmission >

13 20

Possibly an endless loop in my benchmark code?
by Michail Pevnev 18 Aug '18

18 Aug '18

Hello everyone! At the moment I'm working on a function that computes the rank of a matrix. The testing I've performed doesn't seem to reveal anything obviously wrong with what I have so far, so I've decided to see if it can be improved performance-wise. I've sketched up a minimalist criterion benchmark, and run it with profiling options on. But something in the code causes the benchmark executable to loop endlessly. I've stuck a few 'trace's into the code, and it seems that it just keeps on producing and processing more and more matrices. I can kill the process via 'Ctrl-C', and if I do, a profiling report appears. I have attached one here, if you want to see it in full, but the gist is that 70% of time the program does nothing, 10% it does something labeled 'SYSTEM', and another 9% are garbage collection, with the rest of the functions taking less than 2% each. This can go on for more than an hour. At first I've attributed this to the function in question being grossly inefficient, but in the test executable 100 runs of this function on 100x100 matrices take only 18-20 seconds (well, it's actually a test to see if the transpose of a matrix has the same rank as the original, so there's some extra overhead here). What could cause this behaviour? One weak point I can identify myself is 'NFData' (from deepseq package) instance for my matrices - I'm not 100% certain it's correct and does what it should. I don't really think it's the case, though - 'rnf' method of 'NFData' class would then feature prominently in the profiling report, which it doesn't. 'NFData' instance, benchmarking code and the function in question are below ('rank' lacks a type signature since it's actually a method on 'Matrix' class'): ``` ---- the code that works ---- -- | A generic matrix. May or may not be square. data GenericM e = GenericM Int Int (U.Vector e) deriving (Show, Eq) instance NFData (GenericM e) where rnf (GenericM nrows ncols dat) = rnf (nrows, ncols, dat) rank tolerance m@(GenericM nr nc _) = D.trace "new matrix" $ go 0 0 $ V.map rawData $ rows m where go total col allRows | null allRows = total | col >= nc = total | col >= nr = total | abs (maxRow U.! col) < tolerance = go total (col + 1) allRows | otherwise = go (total + 1) (col + 1) nonZeroed where maxIndex = V.maxIndexBy (comparing (abs . (U.! col))) allRows maxRow = allRows V.! maxIndex allRows' = V.imap multiplyAndAdd allRows nonZeroed = V.ifilter notZero allRows' notZero i v = i /= maxIndex && not (isZeroV tolerance v) multiplyAndAdd i v | i == maxIndex = v | otherwise = U.imap (multAddOne i) v multAddOne i j y | j < col = y | otherwise = y - (maxRow U.! j) * coef i coef i = (allRows V.! i U.! col) / maxRow U.! col ---- the code that benchmarks ---- genericDenseMatrixRank :: Benchmark genericDenseMatrixRank = bgroup "linear/matrix/dense/generic/rank" [ env (genRandomGenericMatrix 100) (b "small") --, env (genRandomGenericMatrix 1000) (b "medium") --, env (genRandomGenericMatrix 5000) (b "big") ] where b name m = bench name $ whnf (rank 1e-6) m genRandomGenericMatrix :: Int -> IO (GenericM Double) genRandomGenericMatrix size = do rng <- getStdGen let v = randoms rng :: [Double] return $ mkGenericMFromList size size v ``` Thanks in advance. -- Michail.

1 0

multiline mode on ghci 8.2.2
by Fabien R 16 Aug '18

16 Aug '18

I thought I could use the directive ":set +m" to define a function with its signature. Prelude> :set +m Prelude> square :: Num a=>a->a <interactive>:3:1: error: Variable not in scope: square :: a1 -> a1 Instead, I have to type: Prelude> :unset +m Prelude> :{ Prelude| square :: Num a=>a->a Prelude| square = (^2) Prelude| :} Prelude> Any hint ? -- Fabien

3 2

First CfP: JFP Special Issue on The Theory and Practice of Algebraic Effects and Handlers
by KC Sivaramakrishnan 16 Aug '18

16 Aug '18

============================================================ CALL FOR PAPERS JFP Special Issue on The Theory and Practice of Algebraic Effects and Handlers Submission Deadline: 18 January 2019 Expected Publication Date: December 2019 ============================================================= ## Scope An important aspect of real-world languages is their support for computational effects such as raising exceptions, printing to the screen, accessing a database, non-determinism, and concurrency. In order to reason about the semantics of a programming language with computational effects, it is necessary to separate the effects out from the rest of the language. To this end, algebraic effects permit a wide class of computational effects to be specified in a pure setting using only operations that give rise to them and equations that the operations satisfy. The algebraic treatment of operations naturally leads to a novel treatment of handlers for all computational effects, not just for exceptions. Algebraic effect handlers have been steadily gaining attention as a programming language feature since they generalise many control-flow abstractions such as exception handling, iterators, async/await, or backtracking, while ensuring that the composition of various features remains well-behaved. Indeed, there are implementations of algebraic effects and effect handlers as libraries in C, Clojure, F#, Haskell, OCaml, Scala, JavaScript, as well as full-fledged languages such as Eff, Frank, Links, Koka, and Multicore OCaml. Algebraic effect handlers have also influenced the design of software tools in industry including Facebook's React UI library and Uber's Pyro probabilistic programming language. To recognise and encourage the publication of mature research contributions in this area, a special issue of the Journal of Functional Programming (JFP) will be devoted to the same theme. ## Topics Full-length, archival-quality submissions are solicited on theoretical and practical aspects of algebraic effects and handlers. Examples include, but are not limited to: * Reasoning about algebraic effects and handlers (denotational semantics, dependent types, logical relations, language support for equational reasoning) * Effect typing (subtyping, row-polymorphism, generativity, encapsulation) * Implementation of effect handlers (dynamic effects, selective CPS translations, delimited continuations) * Applications of algebraic effect handlers (probabilistic programming, event correlation, meta-programming, asynchronous I/O, debugging) Reports on applications of these techniques to real-world problems are especially encouraged, as are submissions that relate ideas and concepts from several of these topics, or bridge the gap between theory and practice. Papers will be reviewed as regular JFP submissions, and acceptance in the special issue will be based on both JFP's quality standards and relevance to the theme. The special issue also welcomes high-quality survey and position papers that would benefit a wide audience. Authors are encouraged to indicate interest in submitting by December 14, 2018, to aid in identifying suitable reviewers. The submission deadline is January 18, 2019. The expected submission length is 25-35 pages, excluding bibliography and appendices. Shorter submissions are encouraged; prospective authors of longer submissions should discuss their plans with the special issue editors in advance. Submissions that are based on previously-published conference or workshop papers must clearly describe the relationship with the initial publication, and must differ sufficiently that the author can assign copyright to Cambridge University Press. Prospective authors are welcome to discuss such submissions with the editors to ensure compliance with this policy. ## Submissions Submissions should be sent through the JFP Manuscript Central system at https://mc.manuscriptcentral.com/cup/jfp_submit. Choose “Effects and Handlers” as the paper type, so that it gets assigned to the special issue. For other submission details, please consult an issue of the Journal of Functional Programming or see the Journal's web page at http://journals.cambridge.org/jid_JFP. ## Tentative Schedule * 14 December 2018: Expression of interest * 18 January 2019: Submission deadline * 22 April 2019: First round of reviews * 23 August 2019: Revision deadline * 15 November 2019: Second round of reviews * 13 December 2019: Final accepted versions due ## Guest Editors * Andrej Bauer, Faculty of Mathematics and Physics, University of Ljubljana * KC Sivaramakrishnan, Department of Computer Science and Technology, University of Cambridge ## Editors in Chief * Jeremy Gibbons, Department of Computer Science, University of Oxford * Matthias Felleisen, College of Computer and Information Science, Northeastern University

1 0

WG:
by Stefan Chacko 16 Aug '18

16 Aug '18

Dear Haskell supporters, I have a some question about the definitions in haskell. 1. What is the use of making definitions compared to having no definitions? Is it just like a comment for documation or does it really make a difference in compiling the code? 2. What does the arrow(->) mean in such a definition? Is it a binary operation as *, +, -, <,>,= or is it something else? For example there is sumWithL :: [Int] -> Int -> Int Does this mean in other words [Int]+Int=Int 1. Why do we use clinches in such definitions. I concluded you need clinches if a function is not associative such as (a-b)+c . (Int->Int)->Int->Int But also if a higher order function needs more than one argument. (a->b)->c . Can you please explain it ? Thank you Kind regards. Gesendet von Mail<https://go.microsoft.com/fwlink/?LinkId=550986> für Windows 10

5 4