- Haskell-Cafe - Haskell.org

Multi-param typeclass as superclass of Single-param typeclasses
by Tomasz Chronowski 27 Oct '17

27 Oct '17

This is my first post here, so Hello everyone! In haskell it is possible to express a constraint "if 'a' and 'b' are instance of 'AB' then 'a' is instance of 'A' and 'b' is instance of 'B'": class (A a, B b) => AB a b ... Is it possible to express the converse - "if 'a' is instance of 'A' and 'b' is instance of 'B' then 'a' and 'b' are instance of 'AB'"? I want to create a list of shapes that can be tested for intersection. I think that possibility of expressing such constraints would allow to doing this in a "Object Oriented" way: data Circle = Circle { ... } data Square = Square { ... } class Shape a class Intersect a b where intersect :: a -> b -> Bool -- pseudo haskell - "If 'a' is instance of 'Shape' and 'b' is instance of 'Shape' then 'a' and 'b' are instance of 'Intersect'" -- maybe some type hackery allows to express this? constraint Shape a, Shape b => Intersect a b instance Shape Circle instance Shape Square instance Intersect Circle Circle ... instance Intersect Circle Square ... ... data ShapeBox = forall a. Shape a => ShapeBox a foo = let x:y:_ = [ShapeBox Circle { ... }, ShapeBox Square { ... }, ...] in intersect x y -- this should work because we know for sure that there is an instance of Intersect for type of 'x' and type of 'y' Is such idea already described somewhere?

3 2

Call for Workshop Proposals: ICFP 2018
by Lindsey Kuper 27 Oct '17

27 Oct '17

[ Please disregard previous version sent with the wrong subject line. ] CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2018 23rd ACM SIGPLAN International Conference on Functional Programming September 23-29, 2018 St. Louis, Missouri, United States http://conf.researchr.org/home/icfp-2018 The 23rd ACM SIGPLAN International Conference on Functional Programming will be held in St. Louis, Missouri, United States on September 23-29, 2018. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as tutorials) to be affiliated with ICFP 2018 and sponsored by SIGPLAN. These events should be less formal and more focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on September 23 (the day before ICFP) and September 27-29 (the three days after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: November 20, 2017 Notification of acceptance: December 18, 2017 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2017 workshop co-chairs (Christophe Scholliers and David Christiansen), via email to icfp-workshops-2018(a)googlegroups.com by November 20, 2017. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by December 18, 2017, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2018-files/icfp18-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://www.sigplan.org/Resources/Proposals/Sponsored/ ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2018 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: Christophe Scholliers (University of Ghent) Workshop Co-Chair: David Christiansen (Indiana University) General Chair: Robby Findler (Northwestern University) Program Chair: Matthew Flatt (University of Utah) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (Christophe Scholliers and David Christiansen), via email to icfp-workshops-2018(a)googlegroups.com

1 0

Call for Participation: ICFP 2017
by Lindsey Kuper 27 Oct '17

27 Oct '17

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2018 23rd ACM SIGPLAN International Conference on Functional Programming September 23-29, 2018 St. Louis, Missouri, United States http://conf.researchr.org/home/icfp-2018 The 23rd ACM SIGPLAN International Conference on Functional Programming will be held in St. Louis, Missouri, United States on September 23-29, 2018. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as tutorials) to be affiliated with ICFP 2018 and sponsored by SIGPLAN. These events should be less formal and more focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on September 23 (the day before ICFP) and September 27-29 (the three days after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: November 20, 2017 Notification of acceptance: December 18, 2017 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2017 workshop co-chairs (Christophe Scholliers and David Christiansen), via email to icfp-workshops-2018(a)googlegroups.com by November 20, 2017. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by December 18, 2017, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2018-files/icfp18-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://www.sigplan.org/Resources/Proposals/Sponsored/ ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2018 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: Christophe Scholliers (University of Ghent) Workshop Co-Chair: David Christiansen (Indiana University) General Chair: Robby Findler (Northwestern University) Program Chair: Matthew Flatt (University of Utah) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (Christophe Scholliers and David Christiansen), via email to icfp-workshops-2018(a)googlegroups.com

1 0

Automatically using boxed or unboxed vectors
by Jake Waksbaum 26 Oct '17

26 Oct '17

I am trying to create a data type that is an vector of values, but internally uses an unboxed vector when possible and a boxed array otherwise. If this already exists, let me know. For example, any easily unboxed type is stored in an unboxed array, but also any type that is a product type of only easily unboxed types like (Int, Int) is stored in multiple unboxed arrays. I don’t think there is a smart way of doing this for sum types, so those are stored in boxed arrays. I’m trying to create a typeclass class VectorElement a where data Vector a replicate :: Int -> a -> Vector a length :: Vector a -> Int to represent things that can be stored in Vectors. I can then implement it for specific types that I know can be stored in unboxed vectors: instance VectorElement Int where newtype Vector Int = VectorInt (U.Vector Int) deriving Show replicate len x = VectorInt $ U.replicate len x length (VectorInt v) = U.length v I also want to automatically derive instances of this class for other types using the Generic typeclass. Ideally these instances would be the most efficient possible, so that for example the instance for (Int, Int) used two unboxed arrays but the instance for Maybe Int uses a boxed array. To that end I created another typeclass and wrote instances for the Generic data constructors: class VectorElementG (r :: * -> *) where data VectorG r replicateG :: Int -> r a -> VectorG r lengthG :: VectorG r -> Int instance VectorElementG V1 where data VectorG V1 replicateG = undefined lengthG = undefined instance VectorElementG U1 where newtype VectorG U1 = VectorGUnit Int replicateG i U1 = VectorGUnit i lengthG (VectorGUnit i) = i instance VectorElement a => VectorElementG (K1 i a) where newtype VectorG (K1 i a) = VectorGK (Vector a) replicateG i (K1 x) = VectorGK $ replicate i x lengthG (VectorGK v) = length v instance (VectorElementG r1, VectorElementG r2) => VectorElementG (r1 :*: r2) where data VectorG (r1 :*: r2) = VectorGProd (VectorG r1) (VectorG r2) replicateG i (a :*: b) = VectorGProd (replicateG i a) (replicateG i b) lengthG (VectorGProd v _) = lengthG v instance VectorElement ((r1 :+: r2) p) where newtype Vector ((r1 :+: r2) p) = VectorSum (V.Vector ((r1 :+: r2) p)) replicate i x = VectorSum $ V.replicate i x length (VectorSum v) = V.length v instance VectorElementG f => VectorElementG (M1 i c f) where newtype VectorG (M1 i c f) = VectorGMeta (VectorG f) replicateG i (M1 f) = VectorGMeta $ replicateG i f lengthG (VectorGMeta v) = lengthG v I’m not sure if these are correct, especially the one for :+:. I want basically base cases to be any type that already has an instance of VectorElement or a sum type which is automatically boxed, and the recursive case to basically just use parallel vectors for product types. I think this sort of worked insofar as it allowed me to write an instance for tuples: instance (VectorElement a, VectorElement b) => VectorElement (a,b) where newtype Vector (a, b) = VectorTuple (VectorG (Rep (a, b))) replicate i x = VectorTuple $ replicateG i (from x) length (VectorTuple v) = lengthG v Ideally, however, the compiler would automatically derive this instance using the Generic instance. Is there a way to do that also? I would welcome any thoughts on this entire idea and approach. Thanks, Jake Waksbaum

2 1

Call for Haskell.org Committee Nominations
by Alan & Kim Zimmerman 25 Oct '17

25 Oct '17

Dear Haskellers, It is time to put out a call for new nominations (typically but not necessarily self-nominations) to the haskell.org committee. We have three members of our committee due for retirement -- Ryan Trinkle, John Wiegley and Alan Zimmerman. To nominate yourself, please send an email to committee at haskell.org by December 1, 2017. The retiring members are eligible to re-nominate themselves. Please feel free to include any information about yourself that you think will help us to make a decision. The Haskell.org committee serves as a board of directors for Haskell.org, a 501(c)3 nonprofit which oversees technical and financial resources related to Haskell community infrastructure. Being a member of the committee does not necessarily require a significant amount of time, but committee members should aim to be responsive during discussions when the committee is called upon to make a decision. Strong leadership, communication, and judgement are very important characteristics for committee members. The role is about setting policy, providing direction/guidance for Haskell.org infrastructure, planning for the long term, and being fiscally responsible with the Haskell.org funds (and donations). As overseers for policy regarding the open source side of Haskell, committee members must also be able to set aside personal or business related bias and make decisions with the good of the open source Haskell community in mind. We seek a broad representation from different segments of the Haskell world -- including but not limited to those focused on education, those focused on industrial applications, those with background in organizing users-groups, and those focused directly on our technical infrastructure. More details about the committee's roles and responsibilities are on https://wiki.haskell.org/Haskell.org_committee If you have any questions about the process, please feel free to e-mail us at committee at haskell.org, or contact one of us individually. Regards, Alan Zimmerman

1 0

[ANN] Call for Contributions: BOB 2018 - Berlin, Feb 23, 2018
by Stefan Wehr 24 Oct '17

24 Oct '17

Call for Contributions BOB Conference 2018 "What happens when we use what's best for a change?" http://bobkonf.de/2018/en/cfp.html Berlin, February 23 Deadline: October 29, 2017 You are actively engaged in advanced software engineering methods, implement ambitious architectures and are open to cutting-edge innovation? Attend this conference, meet people that share your goals, and get to know the best software tools and technologies available today. We strive to offer a day full of new experiences and impressions that you can use to immediately improve your daily life as a software developer. If you share our vision and want to contribute, submit a proposal for a talk or tutorial! Topics ------ We are looking for talks about best-of-breed software technology, e.g.: - functional programming - persistent data structures and databases - types - formal methods for correctness and robustness - abstractions for concurrency and parallelism - metaprogramming - probabilistic programming - math and programming - controlled side effects - beyond REST and SOAP - effective abstractions for data analytics - ... everything really that isn’t mainstream, but you think should be. Presenters should provide the audience with information that is practically useful for software developers. We’re especially interested in experience reports. But this could also take other forms, e.g.: - introductory talks on technical background - overviews of a given field - demos and how-tos Requirements ------------ We accept proposals for presentations of 45 minutes (40 minutes talk + 5 minutes questions), as well as 90 minute tutorials for beginners. The language of presentation should be either English or German. Your proposal should include (in your presentation language of choice): - an abstract of max. 1500 characters. - a short bio/cv - contact information (including at least email address) - a list of 3-5 concrete ideas of how your work can be applied in a developer’s daily life - additional material (websites, blogs, slides, videos of past presentations, ...) Submit here: https://docs.google.com/forms/d/e/1FAIpQLSdjgwulSMpaITJ6q6cK_ndrfR1FlEs_HQl… Organisation - direct questions to contact at bobkonf dot de - proposal deadline: October 29, 2017 - notification: November 13, 2017 - program: December 1, 2017 NOTE: The conference fee will be waived for presenters, but travel expenses will not be covered. Speaker Grants -------------- BOB has Speaker Grants available to support speakers from groups under-represented in technology. We specifically seek women speakers and speakers who are not be able to attend the conference for financial reasons. Details are here: http://bobkonf.de/2018/en/speaker-grants.html Shepherding ----------- The program committee offers shepherding to all speakers. Shepherding provides speakers assistance with preparing their sessions, as well as a review of the talk slides. Program Committee ----------------- (more information here: http://bobkonf.de/2018/en/programmkomitee.html) - Matthias Fischmann, zerobuzz UG - Matthias Neubauer, SICK AG - Nicole Rauch, Softwareentwicklung und Entwicklungscoaching - Michael Sperber, Active Group - Stefan Wehr, factis research Scientific Advisory Board - Annette Bieniusa, TU Kaiserslautern - Torsten Grust, Uni Tübingen - Peter Thiemann, Uni Freiburg

1 0

Why is Haskell so slow (comparing to Java/Scala)?
by Станислав Черничкин 23 Oct '17

23 Oct '17

I've wrote simple Haskell benchmark program, which populated primitive vector from vector package: import Data.Vector.Primitive.Mutable as P vectorBench :: Benchmark vectorBench = bgroup "vector" [ primitive ] where primitive = bgroup "primitive" [ write1M ] where write1M = bench "write1M" $ nfIO $ do v <- P.unsafeNew 1000000 void $ for [0..1000000 - 1] $ flip (P.unsafeWrite v) (1 :: Int) return () I use `unsafeNew` to skip memory initialization and `unsafeWrite` to skip boundary checks, I guess it's fastest possible way to write something to vector. My result was about 40 ms. I wrote similar program in Scala: for (_ <- 1 to 5) { val start = System.currentTimeMillis() val a = new Array[Long](1000000) for (i <- 0 until 1000000) { a(i) = 1L } val end = System.currentTimeMillis() println(s"${end - start} ms") } I skip neither boundary checks nor memory initialization, I also used generic array here (suitable for any types of objects, not just for primitive types), so I expected longer run time. But what I got was shocking: 7 ms 3 ms 2 ms 1 ms 2 ms This program runs 20-40 times faster than Haskell after warm-up. 20-40 times, Carl! Why is Haskell soo slooooow? How can it be? -- Sincerely, Stanislav Chernichkin.

6 6

[ANN] Haskell ITA meetup in Rome, Italy (2017-11-18)
by Francesco Ariis 23 Oct '17

23 Oct '17

Dear -cafe, the Italian Haskell Community (http://haskell-ita.it/) is happy to announce its autumn Haskell meetup! The event is going to be hosted in Rome, on November 18th. The meeting will be in Italian; we are going to form small groups/projects, to see Haskell in action and to share knowledge and opinions on functional programming. Everyone, experienced or not, is welcome, just make sure to have a laptop and a working Haskell environment! For a more detailed description of the event and to register, check: https://www.eventbrite.it/e/biglietti-haskell-day-roma-aperitech-38962491862

1 0

[ANN] The Disciplined Disciple Compiler (DDC) v0.5.1
by Ben Lippmeier 23 Oct '17

23 Oct '17

# The Disciplined Disciple Compiler (DDC) v.0.5.1 The Disciple language is an experimental dialect of Haskell which investigates static typing and program transformation in the presence of computational effects. Version 0.5.1 is “working alpha” quality, meaning there is a complete system that can be hacked around with, but it’s not yet industrial strength. Homepage: http://disciple.ouroborus.net/ <http://disciple.ouroborus.net/> Github: https://github.com/DDCSF/ddc <https://github.com/DDCSF/ddc> ## Features: * Haskell-like source language, so Haskell-like programs should work with minor modifications. * Modal region and effect system using ‘box’ and ‘run’ to suspend and force computations. * Higher rank polymorphism with bidirectional type inference. * Simple two space copying garbage collection. * Default call-by-value evaluation. * Typed external core language. ## New in This Release: * Copying garbage collection. We now do simple two space Cheney-scan garbage collection, and grow the heap as needed. We use LLVM shadow stack support to retrieve the GC roots. * Implicit parameters. We now support Agda-style implicit parameters, where arguments are construct at use-sites using whatever bindings are currently in scope. For example, we can perform Haskell-style ad-hoc overloading using implicit dictionaries: elem {Eq a} (k: a) (xx: List a): Bool = case xx of Nil -> False Cons x xs | x == k -> True | otherwise -> elem k xs * Floating point primitives. The addition of floating point primitives combined with proper storage management now lets us write more realistic example programs, like the ray tracer demo, which was also described on the blog [1]. * Travis continuous integration. Every push to the GitHub repo now gets tested by the Travis buildbot [2]. Branches can also be tested individually before being merged. * Support for LLVM versions 3.1 - 5.0 We query the version of the installed LLVM compiler and generate LLVM code with the required syntax. This process now works for versions 3.1 through to 5.0, which is the latest at the time of this release. * New home page with the start of a language specification. The home page now consists of the user manual generated from Sphinx / Restructured Text source. The manual includes grammars for source and core lanuages, as well as previous release notes. The bug tracker is still accessible via the development wiki. * Bug fixes for offside rule, compilation of nested pattern matching, string escapes, unsolved meta variables. Now with more bake. [1] http://disciple-devel.blogspot.com.au/2017/07/ray-tracer-demo.html <http://disciple-devel.blogspot.com.au/2017/07/ray-tracer-demo.html> [2] https://travis-ci.org/DDCSF/ddc <https://travis-ci.org/DDCSF/ddc> [3] http://disciple.ouroborus.net/ <http://disciple.ouroborus.net/> ## Work In Progress We are moving to a new indexed binary format for interface files, as re-parsing interface files is currently a bottleneck. The file format is to be provided by the Shimmer project [4], which has been split out into a separate repository. [4] https://github.com/DDCSF/shimmer <https://github.com/DDCSF/shimmer> ## People The following people contributed to DDC since the last release: * Chris Hall - Travis continuous integration. * Amos Robinson - Build system fixes, start on machine fusion transform. * Ben Sinclair - Build system fixes. * Jacob Stanley - Copying garbage collection. * Ben Lippmeier - Copying garbage collection, implicit parameters, floating point, new home page. ## Previous Releases * 2016/09 DDC 0.4.3: Nested patterns and guards, simple type synonyms. * 2016/04 DDC 0.4.2: Compilation of higher order functions, run and box casts. * 2014/03 DDC 0.4.1: Added bi-directional type inference and region extension. * 2013/07 DDC 0.3.2: Added Tetra and Flow language fragments. ## More Information Home Page: http://disciple.ouroborus.net <http://disciple.ouroborus.net/> The GitHub site: http://github.com/DDCSF/ddc <http://github.com/DDCSF/ddc> Development Wiki: http://trac.ouroborus.net/ddc <http://trac.ouroborus.net/ddc> Development Blog: http://disciple-devel.blogspot.com.au/ <http://disciple-devel.blogspot.com.au/> Mailing List: http://groups.google.com/group/disciple-cafe <http://groups.google.com/group/disciple-cafe>

1 0

Failing Travis CI Build
by Steven Leiva 22 Oct '17

22 Oct '17

Hi Everyone, I am trying to contribute to a smallHaskell project in order to break out of structured learning via books into some real-world code. Unfortunately, the pull request that I made (linked above) is failing the continuous integration check. You can see a partial log before. The entire logs can be found here. I thought that this would work because: 1. We are using the 8.20 resolver in our project. 2. The 8.20 resolver includes QuickCheck, hspec, and quickcheck-instances. 3. The dependencies are listed in the cabal file. Am I missing something obvious? Is the above not the way it works? Thank you for any help. Logs Reading available packages...Choosing modular solver.Resolving dependencies...Could not resolve dependencies:trying: twilio-0.2.0.0 (user goal)rejecting: twilio-0.2.0.0:!test (global constraint requires opposite flagselection)trying: twilio-0.2.0.0:*testnext goal: quickcheck-instances (dependency of twilio-0.2.0.0:*test)fail (unknown package: quickcheck-instances)Dependency tree exhaustively searched.Configuring twilio-0.2.0.0...cabal: At least the following dependencies are missing:QuickCheck ==2.*, hspec ==2.*, quickcheck-instances -any Not using Mixmax yet? Steven Leiva 305.528.6038 leiva.steven(a)gmail.com http://www.linkedin.com/in/stevenleiva

2 3