- Haskell-Cafe - Haskell.org

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

Re: [Haskell-cafe] How to turn Integer into Proxy (n :: KnownNat) with n equal to the integer?
by Johannes Waldmann 15 Aug '18

15 Aug '18

> How can I convert an Integer into a Proxy (n :: KnownNat) > with n equal to the integer? Data.Reflection.reifyNat ? https://mail.haskell.org/pipermail/haskell-cafe/2017-November/128152.html - J.W.

2 1

A function synonym is not (by default) as polymorphic as the original.
by Jeffrey Brown 15 Aug '18

15 Aug '18

Today I was writing a lot of Hashable instances, and found it hard to read code littered long lines mostly consisting of `hashWithSalt`, so I made a synonym: infixl 5 ## (##) = hashWithSalt But when I replaced all the `hashWithSalt`s with ##, I got lots of weird errors -- GHC kept wanting things to be Strings that were Ints, or vice verse. The problem vanished when I added this type signature: (##) :: Hashable a => Int -> a -> Int That's exactly the same type signature that hashWithSalt has. Is this expected behavior? Desirable? -- Jeff Brown | Jeffrey Benjamin Brown Website <https://msu.edu/~brown202/> | Facebook <https://www.facebook.com/mejeff.younotjeff> | LinkedIn <https://www.linkedin.com/in/jeffreybenjaminbrown>(spammy, so I often miss messages here) | Github <https://github.com/jeffreybenjaminbrown>

2 1

Status of the Hi Haddock project
by Simon Jakobi 14 Aug '18

14 Aug '18

Hi! I have summarized the status of my GSoC project at https://sjakobi.github.io/blog/2018/08/14/hi-haddock-3/ My WIP patches for GHC and haddock are at https://phabricator.haskell.org/D5067 and https://github.com/haskell/haddock/pull/906. Cheers, Simon

1 0

Is there a library that has a strict version of `sum`?
by Damian Nadales 14 Aug '18

14 Aug '18

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!

5 4

First Call for Participation for IFL 2018 (Implementation and Application of Functional Languages)
by Jurriaan Hage 14 Aug '18

14 Aug '18

Hello, Please, find below the 1st call for participation for IFL 2018. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- CALL FOR PARTICIPATION: ================================================================================ IFL 2018 30th Symposium on Implementation and Application of Functional Languages University of Massachusetts Lowell, MA, USA September 5th-7th, 2018 http://iflconference.org September 5th: Haskell Mini-Course by Galois, Inc, see details below. ================================================================================ ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2018 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. ### Keynote Speakers * Adam Chlipala, Massachusetts Institute of Technology CSAIL * Arjun Guha, University of Massachusetts Amherst ### Haskell Mini-Course (September 5th, 2018) Mini-course on Haskell by Galois, Inc, presented by David Thrane Christiansen and Jose Manuel Calderon Trilla. Register: Attendance at the course is free, but you must RSVP. (Link to RSVP form can be found at http://iflconference.org) Course Description: Recent versions of the GHC compiler for Haskell feature support for a number of advanced type system features, including pattern-matching functions in the type system (type families), indexed families (generalized algebraic datatypes, or GADTs), type-level data structures (data kinds), and general compile-time metaprogramming (Template Haskell). At Galois, we use these features in a number of our projects, which allows us to build deep embeddings of programming languages and have GHC enforce the target language's type system for us. This style of programming ensures that we only produce well-typed terms, including that we do not forget any of the run-time checks that are necessary to preserve our invariants when accepting input from untyped sources such as files. In the course of developing these projects, some common problems and programming patterns emerged. We developed the `parameterized-utils` library to codify solutions to these problems, and provide necessary generalizations of interfaces from the standard library (Eq, Applicative, Traversable, etc.) We will expect that participants in the course have used Haskell before, but we will not expect everyone to be experts. We will introduce GADTs, type families, and data kinds, and then show how to use them together with the tools from parameterized-utils with an implementation of the simply-typed lambda calculus, including basic AST definitions, evaluation, and parsing. ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jay McCarthy & Matteo Cimini, University of Massachusetts Lowell, USA Program Committee: * Arthur Chargueraud, Inria, FR * Ben Delaware, Purdue University, USA * Christos Dimoulas, Northwestern University, USA * David Darais, University of Vermont, USA * Dominic Orchard, University of Kent, UK * Ekaterina Komendantskaya, Heriot-Watt University, UK * Garrett Morris, University of Kansas, USA * Heather Miller, EPFL & Northeastern University, CH & USA * Jeremy Yallop, University of Cambridge, UK * Keiko Nakata, SAP Innovation Center Potsdam, DE * Laura Castro, University of A Coruna, ESP * Magnus Myreen, Chalmers University of Technology, SWE * Natalia Chechina, Bournemouth University, UK * Peter Achten, Radboud Universiteit Nijmegen, NL * Peter-Michael Osera, Grinnell College, USA * Richard Eisenberg, Bryn Mawr College, USA * Trevor McDonell, University of New South Wales, AUS * Yukiyoshi Kameyama, University of Tsukuba, JAP ### Venue The 30th IFL is organized by the University of Massachusetts Lowell. The City of Lowell is located at the heart of the Merrimack Valley just 30 miles northwest of Boston. Lowell can be easily reached by train or taxi. See the website for more information on the venue.

1 0

What is the right way to use unsafeCoerce?
by Cosmia Fu 14 Aug '18

14 Aug '18

Hi all, I have noticed that unsafeCoerce is able to > Prelude> import Unsafe.Coerce > Prelude Unsafe.Coerce> data P = P Int Double deriving Show > Prelude Unsafe.Coerce> data Q a b = Q a b deriving Show > Prelude Unsafe.Coerce> unsafeCoerce (P 23 2.33) :: Q Int Double > Q 23 2.33 And it works even for sum type, and the first constructor always wins. > Prelude Unsafe.Coerce> data M a = J a deriving Show > Prelude Unsafe.Coerce> unsafeCoerce (J "qwe") :: Either String String > Left "qwe" > Prelude Unsafe.Coerce> unsafeCoerce (Just "qwe") :: M String > J "qwe" And the documenation for unsafeCoerce# says > Casting between two types that have the same runtime representation. One case is when the two types differ only in "phantom" type parameters, for example Ptr Int to Ptr Float, or [Int] to [Float] when the list is known to be empty. Also, a newtype of a type T has the same representation at runtime as T. > http://hackage.haskell.org/package/base-4.11.1.0/docs/GHC-Exts.html#v:unsaf… But info tables for different constructors are different. Why does the code above work? And is it safe to use unsafeCoerce like this? Thanks, Cosmia Fu

2 2