- Haskell-Cafe - Haskell.org

[ANN] Haskell Workshop in Vancouver, BC
by Román González 06 Sep '17

06 Sep '17

`Hello, Is my pleasure to share the news about a new Study Group to learn Haskell using "The Haskell Book". If you live in Vancouver, British Columbia, or know someone that lives here and might be interested in learning Haskell, please share this link with them: https://workshops.vanfp.org/haskell Best Regards. Roman.-

1 0

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 169, Issue 4
by Michal J Gajda 06 Sep '17

06 Sep '17

Hi I can tell a few words about ETL and ML problems in in practice. -- Best regards Michal

2 1

Haskell Numerics / Data Science at ICFP
by dominic＠steinitz.org 05 Sep '17

05 Sep '17

Hello Fellow Haskellers, The organisers of ICFP have very kindly given a room for anyone interested in Haskell Numerics / Data Science on Saturday 9th September 1230-1400. All are welcome and there will be a sign at the reception desk on Saturday morning. I will present a few slides on what we currently have available in our armoury and what might be possible. I plan to spend less than 10 minutes on this. Trevor McDonell has kindly offered to say a few words on accelerate. If anyone wants to give a lightning talk please feel free. Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

How to import hidden modules
by Ricardo Peña 03 Sep '17

03 Sep '17

Hi, I need to define a class instance for the algebraic datatype Data.Map.Map in the Hierarchical GCH libraries, but I do not find the way to import Data.Map.Internal which it is assumed to be hidden. Is there any way to access to this definition? Thanks -Ricardo

3 3

Fwd: issues with ad-hoc polymorphic typeclass instances
by Weylin Lam 02 Sep '17

02 Sep '17

---------- Forwarded message ---------- From: Weylin Lam <lam.dev.hs(a)gmail.com> Date: Sat, Sep 2, 2017 at 8:37 AM Subject: Re: [Haskell-cafe] issues with ad-hoc polymorphic typeclass instances To: Jonas Scholl <anselm.scholl(a)tu-harburg.de> i actually hadn't thought of that! It's an good idea, indeed. The issue is, in terms of DSLs, there'd be no way to prevent a potential mix between the more abstract language and its translation, because expressions are connected to their DSLs via constraints, and here without a class for the language OpEnv, there'd be no way to prevent say the use of ask mixed with addWithEnv, since to use the latter i'd need to put a (Op e, OpEnv e m) constraint... Also, without class i simply couldn't define and use the language OpEnv as is, regardless of the existence of its implementation in terms of Op and Env. Sure for my trivial example it's not very important, but it *is* just a trivial example, it doesn't mean it's always irrelevant... at least i think so. On Sat, Sep 2, 2017 at 7:48 AM, Jonas Scholl <anselm.scholl(a)tu-harburg.de> wrote: > Do addWithEnv and mulWithEnv need to be functions in a type class? > Couldn't you just define them as normal functions? Then all the problems > with undecidable instances are gone. I also don't see how having them in > a type class helps you in any way if you want to define such a far > reaching instance for it. Are there cases where you would need another > instance? If not, then putting it in a plain function is the way to go. > If yes, then you can not define Op and Env for the type of your OpEnv > instance, which seems counterintuitive. Otherwise you would run into > overlapping instances and I don't know if you want that, probably not. > > On 09/02/2017 07:10 AM, Weylin Lam wrote: > > Hello ! > > > > I'm trying to write a polymorphic class instance in function of another > > class. So far it's pretty hard, I have trouble with headsizes and so on. > > I actually had to switch to type families pretty fast, and i'm still not > > out of the woods. > > http://lpaste.net/2650337298029215744 > > <http://lpaste.net/2650337298029215744> > > > > The context: > > It concerns "tagless final interpreters" for EDSLs as described > > in http://okmij.org/ftp/tagless-final/course/lecture.pdf > > <http://okmij.org/ftp/tagless-final/course/lecture.pdf> > > A comparison with free > > monads: http://yowconference.com.au/slides/yowlambdajam2016/ > Hopkins-StopPayingForFreeMonads.pdf > > <http://yowconference.com.au/slides/yowlambdajam2016/Hopkins > -StopPayingForFreeMonads.pdf> > > > > The technique is fairly simple: instead of using ADTs to encode the > > operations of the language, we use haskell's class system. Languages > > become type classes, and interpreters are the instances which give > > various different meanings to the language expressions, which become > > simple haskell, ad-hoc polymorphic values. > > > > It has strong advantages. For example, to write some expression in the > > composition of two languages (two typeclasses), you only need to combine > > the constraints: > > class WriteFile h m where > > writeFile :: h -> String -> m () > > class ReadFile h m where > > readFile :: h -> m String > > > > -- we use Monad m to have access to monadic operations, but the language > > itself > > -- does not care that m be a monad or not. > > myExpression :: (WriteFile h m, ReadFile h m, Monad m) => h -> h -> > > String -> m String > > myExpression h h2 str = writeFile h str *> readFile h2 > > > > The fusion of both languages is utterly seamless, which is the beauty of > > typeclasses. > > > > When writing DSLs, there are at least two basic operations that need to > > be done: combining DSLs to create richer languages (and as just shown, > > it's really simple with this technique), and translating one DSL into > > another. > > > > That latter operation between DSLs is a bit more complicated with > > classes. I haven't found examples of how to do so in the wild (the > > technique doesn't seem very much used, esp compared with free monads), > > so if anybody knows how to do it or has references on that, it'd be much > > appreciated. > > > > Theoretical example of what i'm trying to perform: > > class A a where > > subtract :: a -> a -> a > > class B a where > > add :: a -> a -> a > > neg :: a -> a > > > > -- interpreter from A to B: (doesn't work of course) > > class (B a) => A a where > > subtract x y = add x (neg y) > > > > -- interpreter for B in terms of Int: > > instance B Int where > > add = (+) > > neg = negate > > > > expression :: (A a) => a > > expression = subtract (subtract 4 5) 6 > > -- to get it to be interpreted, we need to select the type. usually we > > use a monomorphic version of id: > > asInt = identity :: Int -> Int > > intExp = asInt expression :: Int > > > > For the instance B Int to be re-usable as instance/interpreter of (A > > Int) expressions, we need a way to write an interpretation of A a in > > terms of any pre-existing interpretation of B b. > > Usually there are some issues, the need to wrap the types into newtype > > wrappers among others. > > > > But in the case i'm trying to solve, it still doesn't work. To see where > > i'm stuck, see above my lpaste. > > > > Any help or ideas would be very welcome! :) Thanks a lot in advance. > > > > > > _______________________________________________ > > 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. >

1 0

issues with ad-hoc polymorphic typeclass instances
by Weylin Lam 02 Sep '17

02 Sep '17

Hello ! I'm trying to write a polymorphic class instance in function of another class. So far it's pretty hard, I have trouble with headsizes and so on. I actually had to switch to type families pretty fast, and i'm still not out of the woods. http://lpaste.net/2650337298029215744 The context: It concerns "tagless final interpreters" for EDSLs as described in http://okmij.org/ftp/tagless-final/course/lecture.pdf A comparison with free monads: http://yowconference.com.au/slides/ yowlambdajam2016/Hopkins-StopPayingForFreeMonads.pdf The technique is fairly simple: instead of using ADTs to encode the operations of the language, we use haskell's class system. Languages become type classes, and interpreters are the instances which give various different meanings to the language expressions, which become simple haskell, ad-hoc polymorphic values. It has strong advantages. For example, to write some expression in the composition of two languages (two typeclasses), you only need to combine the constraints: class WriteFile h m where writeFile :: h -> String -> m () class ReadFile h m where readFile :: h -> m String -- we use Monad m to have access to monadic operations, but the language itself -- does not care that m be a monad or not. myExpression :: (WriteFile h m, ReadFile h m, Monad m) => h -> h -> String -> m String myExpression h h2 str = writeFile h str *> readFile h2 The fusion of both languages is utterly seamless, which is the beauty of typeclasses. When writing DSLs, there are at least two basic operations that need to be done: combining DSLs to create richer languages (and as just shown, it's really simple with this technique), and translating one DSL into another. That latter operation between DSLs is a bit more complicated with classes. I haven't found examples of how to do so in the wild (the technique doesn't seem very much used, esp compared with free monads), so if anybody knows how to do it or has references on that, it'd be much appreciated. Theoretical example of what i'm trying to perform: class A a where subtract :: a -> a -> a class B a where add :: a -> a -> a neg :: a -> a -- interpreter from A to B: (doesn't work of course) class (B a) => A a where subtract x y = add x (neg y) -- interpreter for B in terms of Int: instance B Int where add = (+) neg = negate expression :: (A a) => a expression = subtract (subtract 4 5) 6 -- to get it to be interpreted, we need to select the type. usually we use a monomorphic version of id: asInt = identity :: Int -> Int intExp = asInt expression :: Int For the instance B Int to be re-usable as instance/interpreter of (A Int) expressions, we need a way to write an interpretation of A a in terms of any pre-existing interpretation of B b. Usually there are some issues, the need to wrap the types into newtype wrappers among others. But in the case i'm trying to solve, it still doesn't work. To see where i'm stuck, see above my lpaste. Any help or ideas would be very welcome! :) Thanks a lot in advance.

2 1

To merge package documentation with the platform doc tree
by John Beattie 01 Sep '17

01 Sep '17

Hi, Suppose I download a package and install it. I would like to be able to have the html documentation for that package and I would like it to be integrated with the local doc tree in the haskell platform. Is this a recognised usecase and is there a recommended way to do that? My first thought was to use haddock but I haven't managed to work out if there is a combination of haddock options which would get me there. As an alternative, I was wondering about cloning the GHC platform source and pasting the new library into the source tree alongside the other libraries and building the documentation. I might have to tweak a makefile or somesuch but would that work? Thanks, John Beattie

3 3

megaparsec 6 migration
by ☂Josh Chia (謝任中) 01 Sep '17

01 Sep '17

I'm trying to migrate my codebase from megaparsec 5 to megaparsec 6. There appears to be major changes. For example, Text.Megaparsec.String.Parser & Text.Megaparsec.Error.Dec have both disappeared. I'm sure I could slowly plod through the new documentation, figure out the types and figure out how to migrate the code on my own, but examples & tutorials would be more time-efficient. Are there examples or tutorials compatible with megaparsec 6? For a start, what should I do with the above two things that have 'disappeared'? What do I replace them with? Josh

3 2

Crossreferenced codebase for Stackage LTS 9.2 available
by Robin Palotai 01 Sep '17

01 Sep '17

To find out who else uses your favorite functions and how: http://stuff.codereview.me/lts/9.2 . For example, click 'async' at http://stuff.codereview.me/lts/9.2/#async-2.1.1.1/Control/Concurrent/Async.… to get all the callsites of that method. There are additional files available at http://stuff.codereview.me/ if you want to serve the xrefs locally, or merge your own packages into the index (assuming you use the same stackage lts version). A request: the crossreferencing is pretty usable, but far from complete. If you find any issues (missing crossreferences or bad ones), please have a look at the buglist at https://github.com/google/haskell-indexer/issues, and thumbs-up any that you find hurting, or open new ones! Thank you & happy code browsing, Robin

6 11

ThEdu'17 Post-Proceedings: Call for Papers
by Achim D. Brucker 31 Aug '17

31 Aug '17

(Apologies for duplicates) Call for Papers - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Post-Proceedings --- ThEdu'17 - Electronic Proceedings in Theoretical Computer Science ThEdu'17 --- Theorem proving components for Educational software 6 August 2017, Gothenburg, Sweden, at CADE26 http://www.uc.pt/en/congressos/thedu/thedu17 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Post-Proceedings THedu'17 Scope: Computer Theorem Proving is becoming a paradigm as well as a technological base for a new generation of educational software in science, technology, engineering and mathematics. The workshop brought together experts in automated deduction with experts in education in order to further clarify the shape of the new software generation and to discuss existing systems. This call is open for everyone, also those who did not participate in the workshop. Important Dates (EPTCS Post-Proceedings) * Call for papers: 08 Sep 2017 * Submission (full papers): 17 Nov 2017 * Notification of acceptance: 15 Dec 2017 * Revised papers due: 19 Jan 2018 Topics of interest include: - methods of automated deduction applied to checking students' input; - methods of automated deduction applied to prove post-conditions for particular problem solutions; - combinations of deduction and computation enabling systems to propose next steps; - automated provers specific for dynamic geometry systems; - proof and proving in mathematics education. Submission We welcome submission of papers presenting original unpublished work which is not been submitted for publication elsewhere. The authors should comply with the "instructions for authors", LaTeX style files and accept the "Non-exclusive license to distribute" of EPTCS: Instructions for authors (http://info.eptcs.org/) LaTeX style file and formatting instructions (http://style.eptcs.org/) Copyright (http://copyright.eptcs.org/) Papers should be submitted via easychair, https://easychair.org/conferences/?conf=thedu17 . Program Committee Francisco Botana, University of Vigo at Pontevedra, Spain Achim Brucker, University of Sheffield, United Kingdom Roman Hašek, University of South Bohemia, Czech Republic Filip Maric, University of Belgrade, Serbia Walther Neuper, Graz University of Technology, Austria (co-chair) Pavel Pech, University of South Bohemia, Czech Republic Pedro Quaresma, University of Coimbra, Portugal (co-chair) Vanda Santos, CISUC, Portugal Wolfgang Schreiner, Johannes Kepler University, Austria Burkhart Wolff, University Paris-Sud, France -- Dr. Achim D. Brucker | Software Assurance & Security | University of Sheffield https://www.brucker.ch | https://logicalhacking.com/blog @adbrucker | @logicalhacking

1 0

cabal file build-depends list sensitive to ordering
by Olaf Klinke 30 Aug '17

30 Aug '17

Dear cafe, I discovered that stack/cabal is sensitive to permutations in the dependencies list. Is that desired behaviour and documented anywhere? #File stack.yaml resolver: lts-9.2 packages: - '.' extra-deps: [iCalendar-0.4.0.3,mime-0.4.0.2,wx-0.92.3.0,wxcore-0.92.3.0,wxc-0.92.3.0,wxdirect-0.92.3.0] flags: {} extra-package-dbs: [] system-ghc: false # In file myproject.cabal build-depends: base >= 4.7 && < 5 , HaXml >= 1.13.3 , iCalendar >= 0.3.7.3 , containers , time >= 1.6.0.1 , text , case-insensitive , xslx , xlsx-tabular , wx "stack build" generates the rather uninformative error message In the dependencies for myproject-0.2.1.0: xslx must match -any, but the stack configuration has no specified version # In file myproject.cabal build-depends: base >= 4.7 && < 5 , xlsx , xlsx-tabular , HaXml >= 1.13.3 , iCalendar >= 0.3.7.3 , containers , time >= 1.6.0.1 , text , case-insensitive , wx This version builds just fine. -- Olaf

2 2

profiling of functions generated by LLVM
by Henning Thielemann 30 Aug '17

30 Aug '17

I use LLVM to create sub-routines for efficient inner loops. I like to profile them. However, it seems that GHC's profiler does not interact well with such generated functions. Say, I have a function that creates an efficient subroutine for filling a block of data. It looks like the following: generateFill :: IO (Word64 -> Ptr Float -> IO ()) generateFill = generateFunction (LLVM code for traversing block) main :: IO () main = do let n = 100*10^6 fill <- generateFill allocaArray n $ \ptr -> {-# SCC fill #-} fill (fromIntegral n) ptr I run this with profiling. The resulting .prof report says, that 'generateFunction' demands all the computation time and 'fill' inherits it. fill Main 1297 1 0.0 0.0 99.9 0.0 generateFill Main 1298 0 0.0 0.0 99.9 0.0 generateFunction Main 1299 0 99.9 0.0 99.9 0.0 I have a rough idea why GHC treats the generated functions the way it does. However, it is pretty counter-intuitive and difficult to understand in more complex programs.

1 0

Munich Haskell Meeting, 2017-08-31 @ 19:30
by Christian Neukirchen 29 Aug '17

29 Aug '17

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Thursday, August 31 at Augustiner-Gaststätte Rumpler (Baumstraße 21) at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-aug-2017/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Haddock's Hackage page --- Bravo!
by Albert Y. C. Lai 29 Aug '17

29 Aug '17

https://hackage.haskell.org/package/haddock now puts the whole cheatsheet up front. Well done! Bravo! Whoever thought up this is a genius! Thanks!

7 10

Does the streaming package need a new/additional maintainer?
by David Feuer 28 Aug '17

28 Aug '17

The streaming package has a couple old pull requests that have not been commented on. My recently reported issues and pull requests have also met with silence. It appears that the maintainer, Michael Thompson, was last active on GitHub and Reddit in April. I emailed him a few days ago, but have not yet received a response. I hope he is just on a short break, but if not, someone should probably take over the package. David

1 0

Numerical / Data Special Interest Group at ICFP'17
by Marco Zocca 28 Aug '17

28 Aug '17

Dear all, thanks to the ICFP organisers and to D.Steinitz (https://idontgetoutmuch.wordpress.com/) we will have a late-minute workshop on the numerical and data-related Haskell at ICFP'17 (Oxford) on Saturday 9th September in the slot 12:30 - 14:00. Looking forward to meeting you all there; Best, Marco Zocca https://github.com/ocramz

1 0

GHC 8.2's new ghci commands: `:type +d` and `:type +v`
by Takenobu Tani 28 Aug '17

28 Aug '17

Dear cafe, GHC 8.2 supports two new ghci commands. They are `:type +d` and `:type +v` [1]. 0. normal `:type` command: Prelude> :type length length :: Foldable t => t a -> Int Prelude> :type ($) ($) :: (a -> b) -> a -> b 1. new `:type +d` command for newcomers: Prelude> :type +d length length :: [a] -> Int 2. new `:type +v` command for detail information: Prelude> :type +v ($) ($) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b That's excellent :) [1]: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#g… Regards, Takenobu

1 0

undefined reference to '__gxx_personality_v0'
by Henning Thielemann 28 Aug '17

28 Aug '17

I have trouble to compile my llvm-ffi package containing C++ binding code. I am on Ubuntu 16.04 and I have created a custom llvm.pc file: $ cat /usr/local/lib/pkgconfig/llvm-3.8.pc Name: LLVM Description: Low-level Virtual Machine compiler framework Version: 3.8.0 URL: http://www.llvm.org/ Requires: Conflicts: Libs: -L/usr/lib/llvm-3.8/lib -lLLVM-3.8.0 Cflags: -I/usr/lib/llvm-3.8/include -std=c++0x -std=c++11 /tmp$ cabal unpack llvm-ffi Unpacking to llvm-ffi-3.8.1/ /tmp$ cd llvm-ffi-3.8.1/ /tmp/llvm-ffi-3.8.1$ cabal configure -fbuildExamples --with-ghc=ghc-8.2.1 Resolving dependencies... Configuring llvm-ffi-3.8.1... /tmp/llvm-ffi-3.8.1$ cabal build Preprocessing library for llvm-ffi-3.8.1.. cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C Building library for llvm-ffi-3.8.1.. [ 1 of 22] Compiling LLVM.FFI.Core ( dist/build/LLVM/FFI/Core.hs, dist/build/LLVM/FFI/Core.o ) [ 2 of 22] Compiling LLVM.FFI.BitWriter ( src/LLVM/FFI/BitWriter.hs, dist/build/LLVM/FFI/BitWriter.o ) [ 3 of 22] Compiling LLVM.FFI.BitReader ( src/LLVM/FFI/BitReader.hs, dist/build/LLVM/FFI/BitReader.o ) [ 4 of 22] Compiling LLVM.FFI.Analysis ( src/LLVM/FFI/Analysis.hs, dist/build/LLVM/FFI/Analysis.o ) ... Preprocessing executable 'llvm-ffi-example' for llvm-ffi-3.8.1.. Building executable 'llvm-ffi-example' for llvm-ffi-3.8.1.. [1 of 1] Compiling Main ( example/JIT.hs, dist/build/llvm-ffi-example/llvm-ffi-example-tmp/Main.o ) Linking dist/build/llvm-ffi-example/llvm-ffi-example ... /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMGetHostFeatures: error: undefined reference to 'operator new(unsigned long)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMGetHostFeatures: error: undefined reference to 'operator delete(void*)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMCheckFeature(llvm::StringMap<bool, llvm::MallocAllocator>*, llvm::StringMapConstIterator<bool>*): error: undefined reference to 'operator delete(void*)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMGetFirstFeature: error: undefined reference to 'operator new(unsigned long)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMCreateExecutionEngineKindForModuleCPU: error: undefined reference to 'operator delete(void*)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMCreateExecutionEngineKindForModuleCPU: error: undefined reference to 'std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_replace(unsigned long, unsigned long, char const*, unsigned long)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:function LLVMCreateExecutionEngineKindForModuleCPU: error: undefined reference to 'operator delete(void*)' /tmp/llvm-ffi-3.8.1/dist/build/libHSllvm-ffi-3.8.1-KKUvbYcVYVe5ZjJKumuzkS.a(support.o):support.cpp:DW.ref.__gxx_personality_v0: error: undefined reference to '__gxx_personality_v0' collect2: error: ld returned 1 exit status `gcc' failed in phase `Linker'. (Exit code: 1) StackOverflow discussions on those linker errors suggest that it is important to link with g++, not gcc. Can I control how GHC links? How do other packages cope with C++ code? It seems that they most oftenly come with custom Setup modules that cause trouble with different Cabal versions. I hoped that I can prevent those difficulties using pkg-config. Unfortunately, pkg-config seems to be limited to C libraries. Thus the warnings about the -std=c++11 option in the beginning. Maybe it is cleaner to write a separate LLVM C package that interfaces to the C++ code and bind Haskell to C via pkg-config. However, it would mean that I have to maintain a C library for Linux, Mac and Windows with autoconf et.al.

2 2

how would I do this properly in Haskell?
by Dennis Raddle 25 Aug '17

25 Aug '17

I have a problem which I can solve with OO organization, but I want to know how to do it properly in Haskell. I have a search optimization problem in which there are a lot of individual fitness functions which combine scores to give an overall fitness level. Each fitness function will be associated with data, both initial data to configure it, and a cache that it maintains. So I could have something like this: data Fitness = Fit1 SomeData1 | Fit2 SomeData2 | Fit3 SomeData3 -- this function would evaluate the fitness of a particular -- result of type 'S' (in my case, a partially-constructed -- musical composition) evaluate :: Fitness -> S -> (Fitness,Double) -- something like this would have to be written for -- every sub-type of "Fitness" evaluate (Fit1 d) s = (Fit1 d',v) where (d',v) = evaluate1 d s evaluate1 :: SomeData1 -> S -> (SomeData1,Double) Is there a better way to do this? D

2 4

Announce: Haskell Platform 8.2.1
by Gershom B 25 Aug '17

25 Aug '17

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.2.1 Now available at https://www.haskell.org/platform/ This includes GHC 8.2.1, cabal-install 2.0.0.0, and stack 1.5.1, all with many bugfixes and improvements since the last platform release. A full list of contents is available at https://www.haskell.org/platform/contents.html Thanks to all the contributors to this release, thanks to all the package and tool maintainers and authors, and a big thanks to the GHC team for all their hard work. Due to GHC bug #14081 (https://ghc.haskell.org/trac/ghc/ticket/14081) we do not have Win32 builds in this release. We anticipate resuming support for Win32 once the current issues with GHC on Win32 are fixed in the next release. A list of new GHC changes is available at: https://ghc.haskell.org/trac/ghc/blog/ghc-8.2.11-released A list of cabal changes is available at: https://hackage.haskell.org/package/cabal-install-2.0.0.0/changelog (note the support for the Backpack module system, as described at: https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpa…) The cabal documentation page is at: https://cabal.readthedocs.io/en/latest/ A list of stack changes is at: https://docs.haskellstack.org/en/stable/ChangeLog/ The stack documentation page is at: https://docs.haskellstack.org/en/stable/README/ Happy Haskell Hacking all, Gershom (Note -- one feature we still have not implemented yet for the platform but would like to is a generic linux installer that allows one to set a custom location and does not require root. Anyone who would like to volunteer to help with this, please get in touch!)

2 1

Haskell Platform
by Stuart A. Kurtz 24 Aug '17

24 Aug '17

Dear Colleagues, What's the status of the Haskell Platform? Is it still the/a preferred way to install a working Haskell system? What is the update status of the Platform? [I note that the platform is at 8.0.2, whereas GHC is at 8.2.1, so I'm really asking if there's a roadmap/timeline for updates.] I write because I teach an introductory class in Haskell, and we've long used the Platform as a way to get the system up and running on the student's systems. I'm at a quarter school, but I have to think this is a sharp question for anyone trying to teach a Haskell course at a semester school. Is the Platform still the best way to do this? Will cabal continue to be a reasonable choice as default package manager? Thank you for your consideration. Peace, Stu

6 6

GHC fails to fuse [1 .. 30000000 :: Double] but fuses fromIntegral <$> [1 :: Int .. 30000000]?
by Mateusz Kowalczyk 24 Aug '17

24 Aug '17

Hi, I had few minutes timeout waiting for CI today and I stumbled upon [1]. This is a many years old question and the optimal solution given there was using Vector. I thought that for such a problem it should not be necessary at all. Indeed I wrote `mean :: [Int] -> Int` and got a much faster solution. However the original signature was `mean :: [Double] -> Int`. After trivial changes (change couple of places to Double and add a single fromIntegral) I expected the same result: after all, code is nearly exactly the same. However to my disappointment, the code in question was much slower than the vector solution: how could this be? Looking in Core, I saw that GHC was not getting rid of [Double] like it was with [Int]. I was able to convince GHC to go back to fusing the list into the worker with a `map fromIntegral` but I am unhappy: why is this needed? I don't understand why GHC would not decide to fuse the initial attempt. Honestly it seems like a bug to me. What are your thoughts? For reference here is the core with fromIntegral: as expected, GHC fuses the list and inserts int2Double# as it's generating it: ``` Main.$wgo = \ (w_s5xT :: GHC.Prim.Int#) (ww_s5xX :: GHC.Prim.Int#) (ww1_s5xY :: GHC.Prim.Double#) -> case w_s5xT of wild_Xz { __DEFAULT -> Main.$wgo (GHC.Prim.+# wild_Xz 1#) (GHC.Prim.+# ww_s5xX 1#) (GHC.Prim.+## ww1_s5xY (GHC.Prim.int2Double# wild_Xz)); 30000000# -> (# GHC.Prim.+# ww_s5xX 1#, GHC.Prim.+## ww1_s5xY 3.0e7## #) } ``` Contrast this with version that's commented out in [2]: ``` Main.$wgo = \ (w_s5vE :: [Double]) (ww_s5vI :: GHC.Prim.Int#) (ww1_s5vJ :: GHC.Prim.Double#) -> case w_s5vE of _ [Occ=Dead] { [] -> (# ww_s5vI, ww1_s5vJ #); : y_a3dU ys_a3dV -> case y_a3dU of _ [Occ=Dead] { GHC.Types.D# y1_a3dG -> Main.$wgo ys_a3dV (GHC.Prim.+# ww_s5vI 1#) (GHC.Prim.+## ww1_s5vJ y1_a3dG) } } … case Main.$wgo Main.main3 0# 0.0## … Main.main3 = GHC.Real.numericEnumFromTo @ Double GHC.Classes.$fOrdDouble GHC.Float.$fFractionalDouble Main.main5 Main.main4 … Main.main4 = GHC.Types.D# 3.0e7## … Main.main5 = GHC.Types.D# 1.0## ``` Why? There should be nothing stopping it from doing ``` Main.$wgo = \ (w_s5xT :: GHC.Prim.Double#) (ww_s5xX :: GHC.Prim.Int#) (ww1_s5xY :: GHC.Prim.Double#) -> case w_s5xT of wild_Xz { __DEFAULT -> Main.$wgo (GHC.Prim.+# wild_Xz 1#) (GHC.Prim.+# ww_s5xX 1#) (GHC.Prim.+## ww1_s5xY wild_Xz); 3.0e7## -> (# GHC.Prim.+# ww_s5xX 1#, GHC.Prim.+## ww1_s5xY 3.0e7## #) ``` Perhaps it's afraid to make the pattern match on a floating point number? Insights welcome. [1]: https://stackoverflow.com/questions/3300995/computing-the-mean-of-a-list-ef… [2]: https://stackoverflow.com/a/45840148/1432740 -- Mateusz K.

3 3

Managing a sum type with a lot of constructors
by Adam Flott 24 Aug '17

24 Aug '17

I have a sum type with a lot of constructors and I'm not sure how to represent the type with maintainability in mind. For example, data A = A1 | A2 Int | A3 Text Int32 Bool | ... | A100 Bool Every inner type is concrete. There are 100+ constructors with no sign of ever getting reduced. What technique would you recommend to keep the sum type approach but not having to define them all in one spot? I'm thinking 1 inner type + 1 function to construct per file (if that's possible).

3 3

[ANN] HSvm: Haskell bindings to libsvm library
by Pavel Ryzhov 24 Aug '17

24 Aug '17

Hi all, I am happy to announce the new version of HSvm package: http://hackage.haskell.org/package/HSvm The changelog is: 1. Upgraded to libsvm 3.22. 2. Compatibility with GHC 8.0.2 and GHC 8.2.1. 3. Fixed few bugs in marshaling of C structures. 4. Code cleanup. 5. Documentation is improved. HSvm sources are now available on GitHub: https://github.com/paulrzcz/HSvm The package is also available at Stackage Nightly from 2017-08-17: https://www.stackage.org/nightly-2017-08-17/package/HSvm-0.1.0.3.22 Thanks to Paolo Losi for package and cooperation! Cheers, Pavel

1 0

ANN: Compose :: Melbourne Conference and Unconference [Melbourne, Australia - August 28 & 29]
by Lyndon Maydwell 24 Aug '17

24 Aug '17

Since I don't believe I've updated Haskell Cafe since this year's CFP, on behalf of the Melbourne Committee I'm sending a last-minute reminder that Compose :: Conference Melbourne is running this Monday and Tuesday the 28th and 29th! All information is available online at http://www.composeconference.org/ Tickets are on sale for Day-One on Eventbrite: https://www. eventbrite.com/e/compose-melbourne-2017-tickets-34612742645 Programme: http://www.composeconference.org/2017-melbourne/day-one-program/ The second day (unconference) is free for all and will feature workshops, talks, and many other organised and disorganised activities! Unconference Information: http://www.composeconference.org/2017- melbourne/unconference/ Follow the Melbourne event on Twitter: https://twitter.com/ComposeMelb About Compose and Compose :: Melbourne Compose is a conference for functional programmers, focused on technologies such as Haskell, Scala, Clojure, OCaml, F#, SML and others. Functional programming has been taken up widely, by industry and hobbyists alike. For many of us it has renewed our belief that code should be beautiful, and that programming can be as enjoyable as it is practical. Compose is about bringing together functional programmers of all levels of skill and experience — from technical leads to novices, and from long-time hackers to students just getting started. Our experiences have shown that the theoretical can be put into practice with great success, and that topics once considered “advanced” can be made understandable and spread widely. For example, type systems, often considered complex, can simplify our lives by teaching compilers to do some of our reasoning for us. Compose Conference began in New York in 2015. Warm Regards, - Lyndon

1 0

[ANN] tasty-hedgehog: Adds support for the hedgehog property-based testing library to the tasty testing framework
by David Laing 24 Aug '17

24 Aug '17

Hi, I'm happy to announce tasty-hedgehog: https://hackage.haskell.org/package/tasty-hedgehog They are two great flavours that (now) work together, so I hope it's useful to many of you. There's an example of usage in the README on the GitHub page: https://github.com/qfpl/tasty-hedgehog Cheers, Dave

1 0

How to split (or not split) modules
by Clinton Mead 24 Aug '17

24 Aug '17

Given that one can write modules that just do reexports to control namespaces, it seems to me you've got a lot of flexibility about how you organise your actual code into modules. As long as mutually recursive functions are in the same module and instances are not orphan, you can go from the one extreme of placing all the code on one module to the other extreme of placing each function in a separate module. I believe any performance concerns regarding inlining can be addressed with explicit inline annotations. I can see the point of not having non exported functions in their own module, because to do so would mean producing extra interface code which is never directly used by clients. But other than the concerns mentioned above, I can't really work out whether to have all my code for a package in one module and split it with re-export modules, or have it in lots of little modules and combine it with re-export modules. Any guidance with the pros/cons of both approaches would be appreciated.

1 0

Fwd: Re: 123
by Dmitriy Matrosov 23 Aug '17

23 Aug '17

And even sent the answer not to the list.. Huh. -------- Forwarded Message -------- Oops, i forgot to change the subject. Sorry! On 08/16/2017 09:01 PM, Jack Henahan wrote: > > Some mostly unrelated thoughts: > > An instance head has the form `T a_1 ... a_n`, and the constraint can only > apply to the `a_i`s. Consider the Show instance for > pairs. > > instance (Show a, Show b) => Show (a, b) -- Show ((,) a b) > > The constraints only act on the parameters of the type. > > It looks like you're taking the constraint to mean "whenever I have a Showable > `f String`, this is how to define a Show instance", but a constraint > actually means "use this rule to make a Show instance for any `A f`, and > it is an error if a Show instance for `f String` is not in scope". > > In the second error, you are making the strong claim that your Show > instance for `A f` holds for any `f` and `a`. Even if you could trick > the compiler into allowing that, I don't think it would actually express > the constraint that you want it to. > > Is there something a Show instance gets you that a pretty-print function wouldn't? Well, the `Show` was just an example. And examples with `A` was just a simplified versions, but perhaps oversimplified and hiding original intention. > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE GADTs #-} > {-# LANGUAGE StandaloneDeriving #-} > > import Control.Applicative > import Data.Monoid > import Data.Typeable I want to have a type with many records: > data Volume t = Volume > { _volName :: t String > , _volSize :: t Int > } > > showVolume :: (Show (t String), Show (t Int)) => Volume t -> String > showVolume x = "Volume " ++ show (_volName x) ++ ", " ++ show (_volSize x) with instances parametrized by some other type. E.g. i want to define a `Monoid` based on that other type properties: > instance Alternative t => Monoid (Volume t) where > mempty = Volume {_volName = empty, _volSize = empty} > x `mappend` y = Volume > { _volName = _volName x <|> _volName y > , _volSize = _volSize x <|> _volSize y > } and i may use this like > v1 :: Alternative t => Volume t > v1 = Volume {_volName = pure "vol1", _volSize = empty} > v2 :: Alternative t => Volume t > v2 = Volume {_volName = pure "vol2", _volSize = pure 200} *Main> showVolume (v1 <> v2 :: Volume Maybe) "Volume Just \"vol1\", Just 200" *Main> showVolume (v1 <> v2 :: Volume []) "Volume [\"vol1\",\"vol2\"], [200]" But then i want to define a GADT, which has different behaviors depending on argument type. So different records, depending on their type, will behave differently. > data Config a where > Empty :: Config a > Name :: Last String -> Config String > Size :: Num a => Sum a -> Config a > deriving instance Show a => Show (Config a) > instance Monoid (Config a) where > mempty = Empty > (Name x) `mappend` (Name y) = Name (x `mappend` y) > (Size x) `mappend` (Size y) = Size (x `mappend` y) > x `mappend` Empty = x > Empty `mappend` y = y but i can't even define a `Functor` instance for this type, because `case` branches have different type and `Functor` laws won't hold.. Hm.. instance Functor Config where fmap f Empty = Empty --fmap f (Name s) = case cast f of -- Just g -> case (g s) of -- Just s' -> Name s' -- _ -> Empty -- Nothing -> Empty The other problem is with instances for classes requiring type of kind `*`. I'll end up with what i've asked before: instance (Show a, Show (t a)) => Show (Volume t) where Well, i didn't write that before asking, so i realize all these problems only now (i even forgot to change the subject, what else to say?). And now i don't even sure what the proper subject should be. So thanks and never mind, i need to try more to figure out what to ask. > > Dmitriy Matrosov <sgf.dma(a)gmail.com> writes: > >> Hi. >> >> Is there a way to avoid `UndecidableInstances` in following code: >> >> data A f = A {_a1 :: f String} >> >> instance Show (f String) => Show (A f) where >> >> it does not compile with >> >> 1.hs:4:10: error: >> • The constraint ‘Show (f String)’ >> is no smaller than the instance head >> (Use UndecidableInstances to permit this) >> • In the instance declaration for ‘Show (A f)’ >> >> Though, initially, this was >> >> {-# LANGUAGE RankNTypes #-} >> >> data A f = A {_a1 :: f String} >> >> instance forall f a. Show (f a) => Show (A f) where >> >> which also does not compile with >> >> 1.hs:5:10: error: >> • Variable ‘a’ occurs more often >> in the constraint ‘Show (f a)’ than in the instance head >> (Use UndecidableInstances to permit this) >> • In the instance declaration for ‘Show (A f)’ >> >> The error is different and i don't sure, that this two cases are related. >> >> I want these instances to make a type with many records parametrized by >> `Alternative` type, e.g. >> >> data Volume t = Volume >> { _volName :: t Name >> , _volSize :: t Size >> , _volPath :: t Path >> , _pool :: t Pool >> } >> >> When i try to make instances, which require `*` type, i will end with >> above cases. > > > -- > Jack >

2 2

Experience Report (and [Hiring])
by David Turner 23 Aug '17

23 Aug '17

Hi all, In answer to @snoyberg's call to action a few months back ( https://www.snoyman.com/blog/2017/04/haskell-success-stories) I have written up an experience report and survey results from Tracsis where I currently work: https://davecturner.github.io/2017/08/21/haskell-experience.html Also if you are interested in developer jobs in sunny Leeds and fancy joining our growing team of Haskell developers then there are links in the post with contact information and more details. We're hiring at all levels from fresh graduates up to a new Principal Developer. Please get in touch with me and/or Andrew Handley (CCd) if you'd like to ask any questions. Cheers, David

1 0

Haskell - convert postfix expression to binary tree
by Martin Studna 21 Aug '17

21 Aug '17

Hello, I am trying to convert postfix expression to binary tree. My function takes as argument a list of tokens (strings). Everytime I give the function any input, debugger writes a message: Non-exhaustive patterns in function "add". My idea was: read a token after token and determine, if it is an operator or an operand. If it is operand, don't save any node to the tree and store the number to the stack. Otherwise I create a node with an operator, pop symbols from stack, set them as children of new node and push the operator to stack. If the list of strings is empty, functions print the binary tree. Would someone explain to me, why the function gives non-exhaustive patterns error and how can I fix the function? data Tree = Leaf String | Empty | Node Tree String Tree deriving (Show) add :: Tree -> [String] -> [Tree] -> Tree add (Node l v p) [] stack = (Node l v p) add Empty (x:xs) [] | x `elem` ["*","-","+"] = add (Leaf x) xs [Leaf x] | otherwise = add Empty xs [Leaf x] add Empty (x:xs) (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) xs (Leaf x:a:b:bs) | otherwise = add Empty xs (Leaf x:a:b:bs) add (Leaf x) token (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) token (Leaf x:bs) | otherwise = Leaf x add (Node l v p) (x:xs) (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) xs (Leaf x:bs) | otherwise = add (Node l v p) xs (Leaf x:a:b:bs) parse :: String -> Tree parse input = add Empty (words (toPostfix input)) []

2 1

[ANN] arrowp-qq: an arrowp refresh
by Jose Iborra López 21 Aug '17

21 Aug '17

Dear all, In case anyone finds it useful, there is a new version of arrowp in Hackage that improves the original with a much needed coat of fresh paint. Notable features include a new parser based on haskell-src-exts, a quasi quoter for arrow syntax, and improved desugaring for static choices. https://github.com/pepeiborra/arrowp <https://github.com/pepeiborra/arrowp> The package is in Hackage as **arrowp-qq** due to the impossibility to contact with Ross Paterson (Ross, if you are reading this, please send email!). https://hackage.haskell.org/package/arrowp-qq <https://hackage.haskell.org/package/arrowp-qq> For those of you reading this and wondering why would you want to use a preprocessor for something that GHC can already do, the short answer is that you probably don’t. Using the `proc` quasi quoter --------------------------- ``` addA :: Arrow a => a b Int -> a b Int -> a b Int addA f g = [proc| x -> do y <- f -< x z <- g -< x returnA -< y + z |] ``` Comparison with **arrowp** ----------------------- **arrowp-qq** extends the original **arrowp** in three dimensions: 1. It replaces the `haskell-src` based parser with one based on `haskell-src-exts`, which handles most of GHC 8.0.2 Haskell syntax. 2. It provides not only a preprocessor but also a quasiquoter, which is a better option in certain cases. 3. It extends the desugaring to handle static conditional expressions (currently only if-then-else). Example: ``` proc inputs -> do results <- processor -< inputs if outputResultsArg then outputSink -< results else returnA -< () returnA -< results ``` The standard **arrowp** (and GHC) desugaring for this code is: ``` = ((processor >>> arr (\ results -> (results, results))) >>> (first (arr (\ results -> if outputResultsArg then Left results else Right ()) >>> (outputSink ||| returnA)) >>> arr (\ (_, results) -> results))) ``` This requires an `ArrowChoice`, but there is a more efficient desugaring which performs the choice at compile time and thus an `Arrow` suffices: ``` ((processor >>> arr (\ results -> (results, results))) >>> (first (if outputResultsArg then outputSink else arr (\ results -> ())) >>> arr (\ (_, results) -> results))) ``` Comparison with **GHC** ----------------------- The GHC desugarer does not do a very good job of minimizing the number of `first` calls inserted. In certain `Arrow` instances, this can have a material effect on performance. Example: ``` trivial = proc inputs -> do chunked <- chunk -< inputs results <- process -< chunked returnA -< results ``` This code ought to desugar to a chain of arrows, and indeed, both arrowp and arrowp-qq desugar this to: ``` trivial = chunk >>> process ``` However GHC will produce (approximately) the following code: ``` arr(\inputs -> (inputs,inputs)) >>> first chunk >>> first process >>> arr fst ``` Thanks, Jose Iborra

1 0

Prevent a type parameter from sharing some of its parameters with another parameter
by Timotej Tomandl 21 Aug '17

21 Aug '17

As the title says. Motivation: in a mutable code I want to keep some parameters strictly immutable, i.e. not sharing s with the whole mutable type I think this is best illustrated by 2 examples: 1. abstract example: imagine I have a type X a b c and another type Y a b and I want to prevent any case where the first parameter of X "a" is shared with it's third parameter "c" i.e. X a b (Y a a), X a b (Y a b), X a b (Y b a), X a b (Y a d) etc., any nestings in Y referencing a etc. but allow X a b (Y b b), X a b (Y b c) and any other combination not ruled out above 2. concrete example: imagine I have a type: Item s element key where s is used in the same way as in STRef s a, i.e. it cannot leak outside of a certain context, but I want the key to be immutable i.e. independent of s under any circumstences, so I can't write a type like: Item s element (STRef s refType) this is equivalent to disallowing X a b (Y a d) in 1. Is there any way to write a restriction like this in Haskell? -- Timo

3 3

Ternary infix expression parser
by Jeffrey Brown 19 Aug '17

19 Aug '17

I want to write a parser that lets someone write "(a #uses b) #because (c #needs d)" and read it into a tree: data Tree = Tree String Tree Tree | Leaf String magic "(a #uses b) #because (c #needs d)" = Tree "because" (Tree "uses" (Leaf "a") (Leaf "b")) (Tree "needs" (Leaf "c") (Leaf "d")) I thought I could use Text.Megaparsec.Expr for it, but now I realize it hadnles binary operations, and this is a ternary one. Suggestions? -- 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>

3 3

haskell-src-exts 8.2 compatible release
by Matthew Pickering 18 Aug '17

18 Aug '17

Hi all, I realise that people will be starting to use haskell-src-exts libaries with the new GHC 8.2 release. However, I do not have time in the foreseeable future (~ 1-2 months) to be able to implement the necessary parts to support the new language features. The way to make an 8.2 compatible release happen sooner is to send me some patches! There are some pull requests which I would like to merge but require minor changes or rebasing and also a few language features which need implementing. https://github.com/haskell-suite/haskell-src-exts/milestones/1.18 None of them look very difficult to implement unlike other language changes in past releases. I started to work on what was necessary a few months ago but didn't make a large amount of progress. https://github.com/haskell-suite/haskell-src-exts/tree/ghc-8.2 Anyone's help contributing to this important but menial library would be greatly appreciated. Thanks, Matt

2 1

[ANN] Speculate: automatically discover properties about Haskell functions generalization of counter-examples
by Rudy Matela 17 Aug '17

17 Aug '17

Hello, I am happy to announce Speculate. A library to automatically discover properties about Haskell functions. https://hackage.haskell.org/package/speculate Quick example -- discovering properties about addition and multiplication: $ cabal update $ cabal install speculate $ ghci > import Test.Speculate > speculate args{constants = [constant "+" (+), constant "*" (*)]} _ :: Integer (+) :: Integer -> Integer -> Integer (*) :: Integer -> Integer -> Integer x + y == y + x x * y == y * x (x + y) + z == x + (y + z) (x * y) * z == x * (y * z) (x + x) * y == x * (y + y) x <= x * x Speculate is similar to QuickSpec, but uses a different algorithm to produce inequalities and coditional equations -- see README for details. Speculate is available on both Stackage (nightly) and Hackage. -- Rudy

1 0

Re: [Haskell-cafe] cabal update problem?
by Jonathon Delgado 17 Aug '17

17 Aug '17

01-index.tar.gz is also 4 times the size of 00-index.tar.gz

2 2

DataHaskell impromptu workshop at ICFP'17 ?
by Marco Zocca 16 Aug '17

16 Aug '17

Dear all, among those that will attend the last three days of ICFP (i.e. the Haskell symposium and CUFP), are there people who would be interested in meeting to discuss possible future directions for the DataHaskell project? Looking forward to your feedback; Best, Marco

2 1

cabal update problem?
by yi lu 16 Aug '17

16 Aug '17

Hi all, I find cabal 2.0.0.0 brings new change both in downloading package list and the hackage mirror. 1) 00-index.tar.gz has be replaced by 01-index.tar.gz 2) If timestamp.json exists and it is new enough, 01-index.tar.gz won't download, even though I don't have the latest copy of 01-index.tar.gz. So my questions are 1) What else has been changed to hackage.haskell.org mirror? I found four more files: mirrors.json root.json snapshot.json timestamp.json 2) Is it a feature or a bug? Yours, Yi

1 0

123
by Dmitriy Matrosov 16 Aug '17

16 Aug '17

Hi. Is there a way to avoid `UndecidableInstances` in following code: data A f = A {_a1 :: f String} instance Show (f String) => Show (A f) where it does not compile with 1.hs:4:10: error: • The constraint ‘Show (f String)’ is no smaller than the instance head (Use UndecidableInstances to permit this) • In the instance declaration for ‘Show (A f)’ Though, initially, this was {-# LANGUAGE RankNTypes #-} data A f = A {_a1 :: f String} instance forall f a. Show (f a) => Show (A f) where which also does not compile with 1.hs:5:10: error: • Variable ‘a’ occurs more often in the constraint ‘Show (f a)’ than in the instance head (Use UndecidableInstances to permit this) • In the instance declaration for ‘Show (A f)’ The error is different and i don't sure, that this two cases are related. I want these instances to make a type with many records parametrized by `Alternative` type, e.g. data Volume t = Volume { _volName :: t Name , _volSize :: t Size , _volPath :: t Path , _pool :: t Pool } When i try to make instances, which require `*` type, i will end with above cases. -- Dmitriy

4 4

Re: [Haskell-cafe] Precedence of plus and bit-wise-and
by Doug McIlroy 16 Aug '17

16 Aug '17

Sorry for hitting return prematurely. The final sentence below tells the tale. The reason for the low precedence of & and | in PL/I and C is that those were used as Boolean operators in conditions. For example lessequal(a,b) { return(a<b | a==b); } That usage was baked in before the short-cut operators && and || were introduced in C. doug

1 0

Re: [Haskell-cafe] Precedence of plus and bit-wise-and
by Doug McIlroy 16 Aug '17

16 Aug '17

The reason for the low precedence of & and | in PL/I and C is that those were used as Boolean operators in conditions. For example lessequal(a,b) { return(a<b | a==b); }

1 0

Precedence of plus and bit-wise-and
by Levent Erkok 16 Aug '17

16 Aug '17

I was surprised today to find that C and Haskell differ on the precedence of addition and bit-wise and. In Haskell, bit-wise-and (.&.) binds tighter. In C, it's the other way around. While I like Haskell's precedence better, this was a gotcha; and I wondered if this behavior is documented somewhere. I looked through the Haskell wiki, but couldn't find anything pertinent. Discrepancies are always problematic. Without bike-shedding a lot, does anyone know if this was a conscious decision or merely a more natural one to take? Cheers, -Levent.

4 4

GHC 8.2.1 + lld on FreeBSD
by Sumit Raja 15 Aug '17

15 Aug '17

Hi, I've been playing with ghc 8.2.1 and clang + lld on FreeBSD 11. I wasn't able to get the installation as per release notes to select lld instead of gold (will spend more time exploring why when I get a chance) so I modified the settings file after install. I have builds running okay but I keep seeing the following: [1 of 1] Compiling Main ( hs.hs, hs.o ) Linking hs ... <no location info>: error: Warning: Couldn't figure out linker information! Make sure you're using GNU ld, GNU gold or the built in OS X linker, etc. I've set up ld.lld39 as the shipped lld is 4.0. Although not affecting the actual build ("Hello World") but was interested to know why this was happening. Settings file is below: [("GCC extra via C opts", " -fwrapv -fno-builtin"), ("C compiler command", "clang"), ("C compiler flags", " -fno-stack-protector"), ("C compiler link flags", "-L/usr/local/lib -fuse-ld=lld39"), ("C compiler supports -no-pie", "NO"), ("Haskell CPP command","clang"), ("Haskell CPP flags","-E -undef -traditional"), ("ld command", "ld.lld"), ("ld flags", "-L/usr/local/lib"), ("ld supports compact unwind", "YES"), ("ld supports build-id", "YES"), ("ld supports filelist", "NO"), ("ld is GNU ld", "YES"), ("ar command", "/usr/bin/ar"), ("ar flags", "clqs"), ("ar supports at file", "NO"), ("touch command", "touch"), ("dllwrap command", "/bin/false"), ("windres command", "/bin/false"), ("libtool command", "libtool"), ("perl command", "/usr/local/bin/perl"), ("cross compiling", "NO"), ("target os", "OSFreeBSD"), ("target arch", "ArchX86_64"), ("target word size", "8"), ("target has GNU nonexec stack", "True"), ("target has .ident directive", "True"), ("target has subsections via symbols", "False"), ("target has RTS linker", "@HaskellHaveRTSLinker@"), ("Unregisterised", "NO"), ("LLVM llc command", "llc39"), ("LLVM opt command", "opt39") ] Thanks Sumit

2 1

Haskell in Leipzig 2017: last call for papers
by Wolfgang Jeltsch 14 Aug '17

14 Aug '17

Hi! I want to kindly remind you that the submission deadline of Haskell in Leipzig 2017 is on Friday this week. Looking forward to your contributions. ☺ 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 18, 2017. You will be notified by Friday, September 8, 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 Invited Performer ================= * Lennart Melzer, Robert-Schumann-Hochschule Düsseldorf, Germany 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

[ANN] LeanCheck & Extrapolate: enumerative property-based testing & generalization of counter-examples
by Rudy Matela 14 Aug '17

14 Aug '17

Hello Haskell-café, I am happy to announce LeanCheck and Extrapolate, two enumerative property-based testing libraries (a.k.a. QuickCheck-style testing). https://hackage.haskell.org/package/leancheck https://hackage.haskell.org/package/extrapolate LeanCheck is a list-based enumerative property-based testing library with a very small core of only 180 lines of code. LeanCheck is somewhat stable and has actually been around for a while, but this is its first announcement on haskell-café. It works like so: $ ghci > import Test.LeanCheck > check $ \x y -> x + y == y + (x :: Int) +++ OK, passed 200 tests. Extrapolate works on top of LeanCheck, and its able to produce generalized counter-examples in addition to fully defined ones. Like so: $ ghci > import Test.Extrapolate > import Data.List (nub) > check $ \xs -> nub xs == (xs :: [Int]) *** Failed! Falsifiable (after 3 tests): [0,0] Generalization: x:x:_ Conditional Generalization: x:xs when elem x xs Extrapolate is under active development at the moment. To install both libraries, just: $ cabal update $ cabal install leancheck $ cabal install extrapolate They are also available on Stackage, installable via 'stack install': https://www.stackage.org/package/leancheck (lts-9 and nightly) https://www.stackage.org/package/extrapolate (just nightly) -- Rudy

1 0

[ANN] first release of http2-client
by lucas di cioccio 13 Aug '17

13 Aug '17

Hello, I'm pleased to announce the first release of the http2-client [0] library on Hackage. This version is fresh and has limitations (see README.md) but I can successfully query pages with simple queries on a number of popular websites. I could validate server pushes against GoLang's HTTP2 server demo. I could also hammer Warp with dozens of concurrent requests just fine. I would not recommend using the package for more than evaluation at this point. If you are eyeing towards having a solid HTTP2 client soon, please consider trying http2-client and reporting bugs on the GitHub page [1]. I'm welcoming contribution to the code but I'm also looking forward to build some automation to validate against implementations found "in the wild". Starting this work also allowed me to report/fix a few bugs on Warp's HTTP2 implementation. Hence, even if you are not looking forward to be a http2-client user you may find interest in such work as we all benefit from this. [0] http://hackage.haskell.org/package/http2-client [1] https://github.com/lucasdicioccio/http2-client Best, -- Lucas

1 0

Re: [Haskell-cafe] type (++) = (<>)
by Doug McIlroy 12 Aug '17

12 Aug '17

> What do you think of making (++) the same as (<>) This seems to be a call for returning to the old situation in which (++) was an operator of class MonadPlus. Why was that abolished in Haskell 98? Doug

4 3

Where is the hole?
by Baa 11 Aug '17

11 Aug '17

Hello, Dear List! I have code (this is the fragment only): {-# LANGUAGE CPP #-} ... ... let user' = ... ... else defect $ logger # ("authentication failure (user: " ++ user' ++ ")") #: __LINE__ ... ... and I get compilation error: • Found hole: __LINE__ :: Int Or perhaps ‘__LINE__’ is mis-spelled, or not in scope • In the second argument of ‘(#:)’, namely ‘__LINE__’ In the second argument of ‘($)’, namely ‘logger # ("authentication failure (user: " ++ user' ++ ")") #: __LINE__’ In the expression: defect $ logger # ("authentication failure (user: " ++ user' ++ ")") #: __LINE__ • Relevant bindings include... ... etc ... But if I change variable name to `userx` (from user'), all is compiled succesflully, no any holes. Where is the hole? --- Best regards, Paul

3 2

How to bring existentially quantified type variables into scope
by Wolfgang Jeltsch 11 Aug '17

11 Aug '17

Hi! GHC has some support for referring to existentially quantified type variables. For example, consider the following definition: > data SomeList = forall a . SomeList [a] With the ScopedTypeVariables extension, you can get hold of the concrete type a used in a SomeList value: > f :: SomeList -> SomeList > f (SomeList [x :: a]) = SomeList xs where > > xs :: [a] > xs = [x, x] However, this approach does not work if there are no fields whose type involves the existentially quantified type variable. Consider, for example, the following definition: > data IsListType a where > > IsListType :: IsListType [b] For each type T, we can match a value of type IsListType T against the pattern IsListType. If this succeeds, we know that T is a list type, but we do not have access to the respective element type. Is there a way to determine existentially quantified type variables like the b in the above example? All the best, Wolfgang

5 7

command-line Haskell with 'ghc -e'
by Takenobu Tani 11 Aug '17

11 Aug '17

Hi cafe, I wrote a simple note: command-line Haskell with 'ghc -e' https://github.com/takenobu-hs/commandline-haskell May Haskell with you :) Regards, Takenobu

2 2