- Haskell-Cafe - Haskell.org

Work on mail.haskell.org beginning, please report any problems
by John Wiegley 23 Dec '16

23 Dec '16

Hello Haskellers, Beginning today, I am upgrading our Postfix installation on mail.haskell.org, and introducing some new options to reduce the amount of spam that hits our mailman server. If you experience delivery problems, or any bounced mail, please send a copy of the full bounce message to my address: jwiegley(a)gmail.com. I'll be making more changes gradually over the next few days, and watching the mail logs, but it's possible that mail accepted before will suddenly start getting rejected, depending on how well-behaved your sending mail server is. Activities planned for this Christmas break are: - [x] Upgrade Postfix to 2.11 - [X] Enable postscreen for pre-queue RBL filtering - [ ] DKIM sign messages sent from mailman - [ ] Implement DMARC policy (i.e., reject incoming messages improperly DKIM signed, or failing SPF check) - [ ] Prevent mail being spoofed from haskell.org addresses - [ ] Tighten sender and recipient restrictions - [ ] Re-assess inbound and outbound rate limits - [ ] Use SpamAssassin for post-queue filtering - [ ] If helpful, enable deep protocol pre-filtering - [ ] Document all the above, so others can help with e-mail admin Thank you, John Wiegley Haskell.org, infrastructure team

3 2

Re: [Haskell-cafe] Work on mail.haskell.org beginning, please report any problems
by Viktor Dukhovni 23 Dec '16

23 Dec '16

> On Dec 22, 2016, at 11:09 PM, John Wiegley <jwiegley(a)gmail.com> wrote: > >> If available as a package for your O/S, might as well use 3.1 > > I'll consider that a second migration, after the dust settles this time > around. I'd need to gain experience with 3.x first on my own server, before > being comfortable enough to do that. The 2.11-based setup I've been running > for a month now on another server. Wietse maintains a strong commitment to backwards-compatibility. While Postfix 3.0 (could equally have been 2.12) brings in new features for distribution maintainers, with dynamically-loadable table drivers on multiple platforms it remains compatible with 2.x releases for users. Your 2.11 configuration will work with 3.1, you may just need to install additional table driver packages, if your O/S maintainer has just started delivering Postfix as multiple components. > >>> - [X] Enable postscreen for pre-queue RBL filtering > >> This makes it possible to combine multiple lower-weight RBLs, that >> individually are not sufficient to reject mail, but you should still use the >> SpamHaus zen RBL in smtpd(8). > > Why is it helpful to run it in smtpd as well? I'm already using: > > postscreen_dnsbl_sites = zen.spamhaus.org*2 ... This is because the TTLs on postscreen whitelists are rather longer than RBL TTLs. If an IP address is added to an RBL, you'll want to refuse access in a timely manner. -- Viktor.

1 0

RebindableSyntax and fail in GHC 8
by Chris Smith 21 Dec '16

21 Dec '16

Hey everyone, Can someone explain to me by GHC 8 causes list comprehension bindings to desugar to use 'fail', when RebindableSyntax is enabled in GHC 8? Note that I do not have monad comprehensions enabled. If I define fail, everything works (apparently regardless of what I define fail to do?!?), but I'd like to understand why it's necessary. Thanks, Chris

3 4

emit custom signal from gtk3 haskell side
by Ruben Astudillo 21 Dec '16

21 Dec '16

Hi all I implement the following custom signal in my code import qualified System.Glib.Signals as Sig updateSignal :: ButtonClass self => Sig.Signal self (IO ()) updateSignal = Sig.Signal $ Sig.connectGeneric "updateSignal" Such, will be called inside of "model" phase of the app. But looking on the gtk3 documentation (and grepping also) I can't find a equivalent of `gtk_signal_emit_by_name`. I don't believe this omission is accidental. Can Anybody guide where to look at? -- -- Ruben

1 0

We're recruiting … why not join us?
by Simon Thompson 21 Dec '16

21 Dec '16

We’re recruiting, and if you’re interested in programming languages, types, logics, or more practical aspects like refactoring and other tools, we’d really welcome an application from you. Simon T. Lecturer in Computing (2 posts) University of Kent - School of Computing We are seeking to appoint two Lecturers in Computing (the equivalent of tenure track, assistant professors), based at our Canterbury campus. We are particularly interested in appointments in Security, or Programming Languages but are happy to consider excellent candidates in other areas that would complement or enhance the School’s existing research strengths. Job description https://www11.i-grasp.com/fe/wrapdev_SendFile.asp?key=49170934&c=3362126282… Additional Information https://www11.i-grasp.com/fe/wrapdev_SendFile.asp?key=49170934&c=3362126282… Please apply at https://www11.i-grasp.com/fe/tpl_kent01.asp?newms=jj&id=40606&aid=14243 Closing date for applications: 6 February 2017 The School of Computing [1] is a welcoming and diverse environment whose commitment to gender equality has been recognised with a Bronze Athena SWAN [2] award. We are keen to enhance the balanced, inclusive and diverse nature of the community within our School and would particularly encourage female candidates to apply for these posts. We are committed to delivering high quality research and education. Our research is focused on five broad research areas: Programming Languages and Systems; Computer Security; Computational Intelligence; Data Science; and Computing Education. Full details can be found at: https://www.cs.kent.ac.uk/research. The 2014 Research Excellence Framework (REF) ranked our school 12th for research intensity [3], and we are well placed to improve on this in the next REF. The University of Kent has campuses in Canterbury and Medway, and specialist postgraduate centres in Athens, Brussels, Paris and Rome. It was ranked 16th in the UK in The Guardian University Guide 2016. It ranked 4th for overall student satisfaction (NSS, 2016) and 17th for the intensity of its excellent research (REF 2014). It has 20,000 students and 1,872 academic, teaching and research staff. Overlooking the city centre, and with 125 nationalities represented, the Canterbury campus has a very cosmopolitan feel. Canterbury is a small city that retains parts of its medieval walls. Famous for its heritage (Canterbury Cathedral; Chaucer’s Tales; etc), Canterbury is a vibrant community whose culture and leisure facilities are enhanced by hosting three universities. The city and surrounding region combines an attractive and affordable environment, good schools, and fast transport links to London and mainland Europe. Links: [1] https://cs.kent.ac.uk/ [2] http://www.ecu.ac.uk/equality-charters/athena-swan/ [3] https://www.timeshighereducation.com/sites/default/files/Attachments/2014/1… Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 1

ANNOUNCE: pdf-slave-1.0 tool for PDF generation from haskintex templates
by NCrashed . 21 Dec '16

21 Dec '16

I am glad to announce first release of pdf-slave, a tool for generation of PDF documents from LaTeX templates with embedded Haskell. Hackage: http://hackage.haskell.org/package/pdf-slave Github: https://github.com/NCrashed/pdf-slave Description ======= In many real-world systems we need to produce reports, cheque and other documents to users. One possible solution is rendering LaTeX files, but it is not flexible enough as you need to solve burden with generation of LaTeX file from varying inputs, manage static files like images and handling dependencies between pieces of document. The new tool takes the burden away. Now all static files and generation code is located within a single template project, that describes how to build your PDF document in a declarative way. Common work flow with pdf-slave: * Develop template from several LaTeX files with embedded Haskell (thanks to haskintex tool) * Pack the template project into bundle all-in file. * Distribute the bundle (for instance, to your service server). * Call pdf-slave with bundle and inputs in JSON file to generate new PDF document. Status ==== pdf-slave is designed as part of commercial Haskell system. The tool is very young and need time approval, although it already has all needed features one may need from such tool. Special thanks to hint authors and Daniel Díaz, developer of awesome HaTex and haskintex, without these packages pdf-slave wouldn't be possible! Reports, feature request, PR are always welcome! Anton Gushcha aka NCrashed

1 0

stack on Windows and C Preprocessor
by Olaf Klinke 20 Dec '16

20 Dec '16

Dear Cafe, not sure who the culprit is, thus trying on this list: My project builds fine with stack on Linux. I installed the latest (1.3.0 x86_64) stack on a Windows box and ran 'stack.exe setup' inside my project's directory. The build fails at the depencency HaXml-1.25.3 with a lexer error on line 34 of this file: http://hackage.haskell.org/package/HaXml-1.25.3/docs/src/Text-XML-HaXml-Wra… lexical error in string/character literal at character '\r' It seems the line (VERSION) is processed by the C preprocessor which somehow messes it up. Unfortunately, stack deletes its temporary files after running into the error, which deprives me of handles to further debug this. Does anyone have an idea how to continue from here? Thanks, Olaf

3 2

Re: [Haskell-cafe] Foo.Bar.hs filenames poll
by Dimitri DeFigueiredo 20 Dec '16

20 Dec '16

I believe it is a mistake to tie the module structure of a software system to a file structure on a hierarchical file system. I see those too structures as different entities. Why can't I coalesce two tiny modules into a single file? I also don't like having to capitalize my file names (Foo.hs instead of foo.hs) in linux, that seems rather ugly. It see this "ugliness" as a symptom of the "arbitrarily forced link" between the module structure and the file structure. Obviously, some conventions should apply, but a one-to-one correspondence seems too strict. Dimitri -- 2E45 D376 A744 C671 5100 A261 210B 8461 0FB0 CA1F

6 5

memoizing with a default
by Michael George 20 Dec '16

20 Dec '16

I've come across a slight variant of memoization and I'm curious if either there is a better way to think about (I have yet to reach Haskell Enlightement), or if it's been thought about before. I'm writing a program that does DFA minimization, as described here: https://www.tutorialspoint.com/automata_theory/dfa_minimization.htm. For me, the simplest way to understand the algorithm is we form an equivalence relation, where two states are different if either one is final and the other isn't, or if there are transitions from them to states that are different. different a b = isFinal a && not (isFinal b) || isFinal b && not (isFinal a) || exists chars (\c -> different (step a c) (step b c)) This definition diverges; it never decides that two states are the same. The standard algorithm builds a table, starting with the assumption that all states are the same, and iteratively applying this definition until it converges. I'm thinking of that algorithm as a memoized version of the implementation of different above. But it's not quite: different = memoFix2 different' where different' different'' a b = isFinal a && not (isFinal b) || isFinal b && not (isFinal a) || exists chars (\c -> different'' (step a c) (step b c)) for the same reason; it diverges. But with memoization I can detect the diversion by putting a marker in the memo table. If the computation makes a recursive call on an input that is started but not computed, then (in this case) I want to return false. In general, I think what I want is memoFixWithDefault :: (a -> b) -> ((a->b) -> (a -> b)) -> (a -> b) Where (memoFixWithDefault default f) is like (memoFix f) except that if (memoFix f a) would loop, then (memoFixWithDefault default f a) = default a. I suspect there's a nice denotational way of describing this, but my denotational semantics is rusty (maybe it's the least fixed point of f that is greater than g or something, but that's not it). I suspect that there needs to be a nice relationship between f and g for memoFixWithDefault f g to be sensible. I also suspect that there's a cute 3-line implementation like all the other implementations of memoize out there, but I don't see it. I also suspect that depth-first search has a cute implementation using this combinator. So I was wondering if other people had thoughts or references before I went off and thought about it. Thanks! -M

6 5

Foo.Bar.hs filenames poll
by Christopher Done 19 Dec '16

19 Dec '16

Short version: here is the poll < https://docs.google.com/forms/d/e/1FAIpQLSdniOfoaX7xflgdWRnjVQ6_VLtk1oxA00S… > I noticed recently that Foo.Bar.hs is supported by GHC. I had always assumed it wasn't because people always use directories. I've never liked having separate directories for each level of hierarchy. It's easier to just list a list of files and script (e.g. even copying a file X.hs to Y.hs is a bummer). When opening them on GitHub you have to click through to get a complete picture of a project. Other languages do and don't do this. Lispers, for example, don't. How do other Haskellers feel about it? Would it mess with anybody's tooling or mojo if I switched to that style in my packages? For one I know that Stack (my own implementation), actually assumes hierarchical filenames. So I'd have to patch that to implement this. E.g. > Unable to find a known candidate for the Cabal entry "HIndent.Types", but did find: HIndent.Types.hs. If you are using a custom preprocessor for this module with its own file extension, consider adding the file(s) to your .cabal under extra-source-files. I suppose the real question is, as a language standard and a community preference, should this be considered a bug? Should people be free to use X.Y.hs or X/Y.hs styles? Ciao!

9 9

ANN: New Haskell.org Committee Members
by Gershom B 19 Dec '16

19 Dec '16

Following the self-nomination period and discussion, the Haskell.org committee has selected new members: Full term: * Mitsutoshi Aoe * Jasper Van der Jeugt * Niki Vazou Short term: * Alan Zimmerman As per the rules of the committee, this discussion was held among the current members of the committee, and the outgoing members of the committee who were not seeking reappointment. Thank you to all the many candidates who submitted a self-nomination. We recieved many strong nominations, from a broad range of geographies and backgrounds. The choice amongst them was not easy, and we would encourage all those who nominated themselves to consider self-nominating again in the future. The outgoing members are: Adam Foltzer, Edward Kmett, Andres Loeh, and Nicolas Wu. Thanks all for your service! These are tough shoes to fill, but I have confidence that our incoming members will more than rise to the occasion. Cheers, Gershom

1 0

Re: [Haskell-cafe] Absolutely confused with error/exception handling
by Saurabh Nanda 18 Dec '16

18 Dec '16

My recommendation is to catch the exception in IO first, before it is lifted into the ActionCtxT. If your business logic is decoupled from the web framework (as it should be) then it should be easy enough to do this. I'm trying to write a "global" error handler which logs unhandled errors to Airbrake along with information from the request object (domain, URL, params, cookies, etc). I understand that I can make this part of my app monad, but if I don't understand why I'm unable to catch errors in MonadIO I'm bound to get stuck again, or implement it incorrectly (for example, what are the resource leaks that were being referred to?) Also what if a particular handler is not in my app monad? How do I prevent someone from accidentally adding a handler without the airbrake integration? -- Saurabh.

2 1

regression in memory usage between 6.10 and 7.x?
by Ben Franksen 17 Dec '16

17 Dec '16

In the functional pearl "A Play on Regular Expressions" by Sebastian Fischer, Frank Huch, and Thomas Wilke, the authors explain how to implement a Glushkov automaton in a very elegant way. They claim that when they compile their code with ghc-6.10.4 and with -O2 optimization they get: """ 1 MB total memory in use ... Total time 0.06s (0.21s elapsed) """ for a program that matches stdin against the equivalent (in grep -E syntax) of ^(a?){500}a{500}$ When I try their code on my machine with ghc-7.10.3 (and also -O2) I get: """ ben@sarun[1]: .../play/regexfp > ghc Reg.hs -O2 -o re [1 of 1] Compiling Main ( Reg.hs, Reg.o ) Linking re ... ben@sarun[1]: .../play/regexfp > ./re 500 +RTS -s True ... 155 MB total memory in use ... Total time 1.031s ( 1.037s elapsed) """ The details of the RTS report furthermore tell me that GC is responsible for more than 80% of the runtime. Now, I certainly have a different machine and perhaps OS than the authors of the paper, but that can't explain a factor of 16 in runtime and of 150 in memory use. I have double and triple checked my code for possible mistakes. I /do/ get the expected results (same as in the paper). I tried different numbers and found n total memory in use / MB 100 8 200 28 500 169 1000 698 which shows that memory consumtion is roughly quadratic in n. I tried heap profiling but that tells me only that all the allocation is done by the function 'shift', which I already knew (or rather guessed). I also tried several compiler versions: 7.0.4, 7.10.3, 7.4.2, 7.6.3, 8.0.1. They all result in similar performance. The ghc version the authors used is 6.10.4 and I don't have a package for that compatible to my distribution. Any hint as to where these differences might come from are appreciated. I have attached the program for reference. Cheers Ben -- "Make it so they have to reboot after every typo." ― Scott Adams

2 2

Absolutely confused with error/exception handling
by Saurabh Nanda 17 Dec '16

17 Dec '16

Hi, What started as a simple exercise of writing an Airbrake integration for Spock, has turned into a day of reading about errors, Control.Exception, MonadThrow, MonadCatch, sync, asynchronous, etc. Even after all that reading I haven't been able to find answers to the following -- * What exactly is done by the "error" function? How does one "trap" those errors and react to it? Can "catch" trap those errors? What is "e" in the case of errors raised by "error"? * How is "error" different from "throw" and "throwIO" (in the Control.Exception package, I believe) * What does MonadThrow and MonadCatch bring to the table? My understanding is that they are bringing a unified API to representing short-circuitable computations based on the inherently short-circuitable value of the host monad. Eg throwM in Maybe just results in a Nothing. throwM in List results in [] Therefore, in most of the cases throwM is not really using the error machinery built into the Haskell language (what said machinery is, is the very first question that I still don't completely understand) All of this might be obvious, and I might have just reached a mind-block after hours of reading. Help would be really appreciated :) -- Saurabh.

4 12

Fwd: Your Assembly at 33C3
by Profpatsch 16 Dec '16

16 Dec '16

We will organize a “Functional Hot-Pot” at 33C3, where friends of functional languages, Haskellistas, Lambdroids and Scalafists can share their experience and have a good time. https://events.ccc.de/congress/2016/wiki/Assembly:Functional_Hot-Pot If you want to maybe organize a workshop or have other ideas, don’t hesitate to contact me (this mail or DECT LBDA). -- Proudly written in Mutt with Vim on NixOS. Q: Why is this email five sentences or less? A: http://five.sentenc.es May take up to five days to read your message. If it’s urgent, call me.

1 1

Optional C dependencies / build-time feature toggles
by Tobias Dammers 14 Dec '16

14 Dec '16

Hello Cafe, I have this project here: https://sprinkles.tobiasdammers.nl/ (source on github: https://github.com/tdammers/sprinkles) and it has a bunch of runtime dependencies on C libraries. Many of them are only required for certain use cases, e.g., the libmysqlclient dependency is only relevant if you want to access MySQL database backends, libfcgi is only required for hosting as FastCGI (which isn't even the recommended first choice), etc. Still, in order to build and run Sprinkles, all the dependencies must be installed, which is of course not ideal. The pipe dream would be for those dependencies to be optional *at run time*, such that the application would test for their presence on startup, or load them dynamically when and if they're needed. However, I'm also fine with making them compile-time feature toggles, such that users can enable only the ones they need. Doing some sort of autotools-style dependency discovery would of course be cool as well (i.e., only enable mysql support if libmysqlclient is present). So the broad question is, which of these are realistic, and how would I go about it? And, regarding feature toggles, this bit in the Cabal FAQ baffles me a little: > Question: I like to let the user enable extended functionality using a > Cabal flag. Is this the right way? > > Answer: Certainly not. Since other packages can distinguish packages > only according to their name and their version, it is not a good idea > to allow different APIs for the same package version. Cumbersome as it > is you have to move extra features to a separate package. Moving the features to a separate package wouldn't really solve anything AFAICT, because I'd still have to bring them together somehow. -- Tobias Dammers - tdammers(a)gmail.com

5 4

Tracing HTTP request/response using servant-client or http-client
by Jan von Löwenstein 14 Dec '16

14 Dec '16

Hi, I wonder if there is a possibility to make servant-client or the layer below, i.e. http-client log all requests and corresponding responses into a log file. There is `managerModifyRequest :: ManagerSettings <https://hackage.haskell.org/package/http-client-0.5.4/docs/Network-HTTP-Cli…> -> Request <https://hackage.haskell.org/package/http-client-0.5.4/docs/Network-HTTP-Cli…> -> IO <https://hackage.haskell.org/package/base-4.9.0.0/docs/System-IO.html#t:IO> Request <https://hackage.haskell.org/package/http-client-0.5.4/docs/Network-HTTP-Cli…> ` ( https://github.com/snoyberg/http-client/blob/master/http-client/Network/HTT…) which would allow to build logging for requests I suppose. However I could neither find a corresponding hook for Response, nor a "batteries included"TM `logRequests = True`, `requestLogger=...` or something along those lines. Best Jan

1 1

Offline compilation with Stack/Cabal
by Jan von Löwenstein 13 Dec '16

13 Dec '16

Hi, Consider the following use case: I have to ship a Haskell application as source, bundled with its dependencies and a script that can produce the binary on a machine without internet connectivity. Is that possible with Stack or Cabal? Any pointers would be much appreciated. Ideally I would like to build each dependency package individually. That way I could cache results per Haskell package and don't need to rebuild dependencies until they actually change. Best Jan

5 8

Modelling structurally subtyped and cyclic data in type safe Haskell
by Aura Kelloniemi 13 Dec '16

13 Dec '16

Hello This is my first post to Haskell Café. I am a hobbyist programmer who has lots of experience with imperative and OO languages ranging from 80286 assembly to Ada and Ruby. Last four years I've been learning Haskell, which has been a painfully educational experience - I have a good understanding about how CPUs work, but very little understanding about maths. This is a very long post, I apologize. Now I'm trying to create a tool which automatically generates foreign function interface (FFI) imports from C and C++ to Haskell. I have written a GCC plugin which extracts all relevant (and lots of irrelevant) information from GCC's TREEs and dumps the output as JSON. It also dumps preprocessor macros which is one of the reasons this tol is being given birth. The tool is used like Shake - import Development.Familiar and write code which glues all relevant data processing and FFI generation functions together. This is also going to be a reusable library which others can use for whatever they find the data to be useful for. This could include making FFI bindings to other languages. Some code analysis tools also might find the data useful. I'm having a hard time importing this data to Haskell in a type safe way. GCC's TREEs are structured in an OO way. I have tried to find a more functional way of representing them, but so far with no luck. The JSON data is typed, and the hierarchy is exactly the same as in GCC. Below I construct a tree of the hierarchy where I list a few of possible types and very few of the fields the data types contain. For listing fields and their types I use a syntax similar to Haskell. This shortened listing should be enough for illustration: * macro: (data fields include: name :: string, tokens :: [token], etc.) * tree: all nodes have a unique ID to be able to recover the cycles among the node graph; (id :: integer) * * translation_unit: (declarations :: [top_level_declaration]) * * constant: a compile-time constant value; (type :: type) * * * complex_constant: (value :: complex) * * * integer_constant: (value :: integer) * * namespace_decl: (name :: identifier, declarations :: [top_level_declaration]) * * declaration: (name :: identifier, type :: type) * * * const_decl: One component of enum type; (value :: type) * * * function_decl: (type :: function_type, params :: [param_decl], result :: result_decl) * * * type_decl: (no additional fields) * * type: (declaration :: type_decl, name :: identifier, size :: integer_constant, alignment :: integer, qualifiers :: [qualifier], completeness :: bool) * * * array_type: (element_type :: type, element_count :: integer) * * * numeric_type: (precision :: integer, signed :: bool, min_value :: integer_constant, max_value :: integer_constant) * * * * enumeral_type: (values :: [const_decl]) * * * function_type: (param_types :: [type], result_type :: type) * * * pointer_type: (referred_type :: type) * * * record_type: struct (C or C++)/union; (base_types :: [(type, access_info)], fields :: [field_decl or const_decl or type_decl], methods :: [method_decl]) * reference: Any node may be replaced by a reference. They can be forward or backward references. (referred_id :: integer) As you may see, tree nodes form many many cycles together. Subclasses sometimes provide stronger invariants for their fields than the parent classes. For example all declarations are associated with a type and for function_decl nodes this type is always a function_type. Now to my question. How to represent this in Haskell. Because of the enormous amount of fields per tree node, I certainly need to use records. -- Haskell follows: data BaseTree = BaseTree { id :: Int, ... ... } data BaseDecl = BaseDecl { baseTree :: BaseTree, name :: Identifier, declType :: Type, ... } data ConstDecl = ConstDecl { baseDecl :: BaseDecl, value :: ConstValue } data ConstValue = ComplexConst Complex | IntegerConst Integer data TypeDecl = TypeDecl { baseDecl :: BaseDecl } But... What shall I do about the heterogenous lists which many nodes contain. I wish I don't need to make myriards of ADTs for them, like: data AnyTopLevelDecl = ATLDConst ConstDecl | ATLDFunction FunctionDecl | ATLDNamespace NamespaceDecl | ATLDType TypeDecl -- ... data StructFieldDecl = SFDConst ConstDecl | SFDField FieldDecl | SFDType TypeDecl And so forth, basicly each heterogenous list gets its own ADT, because there is often variance in which node types can appear in the lists. I could use one big ADT like AnyDecl. However, to me it would feel like a bad design, if my types allowed RecordType nodes to reference NamespaceDecls, and therefore I don't want to pack all nodes into one type, unless I could use some type parameters or constraints to restrict the possible values the ADT could take. At first I thought that the following could solve my problem: data SomeDecl a = SomeDecl where SomeConst :: ConstDecl -> SomeDecl ConstDecl SomeField :: FieldDecl ->SomeDecl FieldDecl SomeFunction :: FunctionDecl -> SomeDecl FunctionDecl SomeType :: TypeDecl -> SomeDecl TypeDecl -- and then I would use type classes like this class TopLevelDecl decl where -- No methods needed instance TopLevelDecl ConstDecl instance TopLevelDecl FunctionDecl instance TopLevelDecl TypeDecl -- And then I could write functions like this: handleTopLevelDecl :: TopLevelDecl d => SomeDecl d -> Whatever handleTopLevelDecl (FunctionDecl f) = -- ... -- and I'd list all cases which have a TopLevelDecl instance, but not -- those which don't have. I also thought that my data types could look like -- this: data NamespaceDecl where NamespaceDecl :: { baseTree :: BaseTree, forall a. TopLevelDecl a => declarations :: [a] } Obviously this does not work, because type classes are open, and even though GHC prevents me from calling handleTopLevelDecl with (SOmeDecl FieldDecl), it still complains if I don't define an equation for it, because in some other module somebody might make a TopLevelDecl instance for FieldDecl. Now I would like to know if there is a way to solve my problem in an elegant way, e.g. by using type families. My second question is how to resolve the cyclicity of the node graph. I don't want to tie the knot, because I want to be able to manipulate the graph. Maps are one option, yes: data AnyNode = (list all possible nodes) type Id = Int type NodeIdMap = Map Id AnyNode -- Then my data types refer to other nodes like this: data FunctionDecl = FunctionDecl { parameters :: [Id] } Now I lose all type safety. I would have to insert a run-time check to every dereference of an Id if I want to make sure that function parameter declarations don't contain StringConstants. I've also considered using STRefs. During JSON parsing I would need to populate the nodes with the node Ids they refer to and then have a separate pass which turns all Ids to typed STRefs. At least with this approach I would get all possible run-time errors straight after parsing, and not when the data is used. I'm again sorry for this long elaboration. However I think that if you consider answering me you have a pretty good understanding of my problem and also a good knowledge of my level of understanding Haskell. I would like to unlearn OO-style thinking, and I would want to find a data and type representation which feels Haskellish. However I don't want to cut down the data. I want all information to be accessible in case somebody needs it. Thank you in advance! -- Aura

4 4

Re: [Haskell-cafe] RFC: functor-classes-compat
by David Feuer 13 Dec '16

13 Dec '16

On Dec 13, 2016 4:01 AM, "Oleg Grenrus" <oleg.grenrus(a)iki.fi> wrote: Hi, continuing pushing the adoption Data.Functor.Classes, I wrote a small package `functor-classes-compat` [1]. It provides lifted (Eq1, Ord1, etc.) classes for types in `containers`, `vector` and `unordered-containers`(not for Sequence or Tree yet though). Thanks for working on this. Obviously, some of these really belong in containers. I'll try to add them today. I guess there is no way they could depend on `transformers` to provide instances in build plans with `base < 4.9`, I'm not sure when I'll have time to write patches for the actual packages myself. No, I don't think that's likely. One option might be to add these instances to transformers when compiling with older base, but I don't know if Ross Paterson will want them. Current implementations are naive, but more obviously correct. More than what?

2 3

RFC: functor-classes-compat
by Oleg Grenrus 13 Dec '16

13 Dec '16

Hi, continuing pushing the adoption Data.Functor.Classes, I wrote a small package `functor-classes-compat` [1]. It provides lifted (Eq1, Ord1, etc.) classes for types in `containers`, `vector` and `unordered-containers`(not for Sequence or Tree yet though). I guess there is no way they could depend on `transformers` to provide instances in build plans with `base < 4.9`, I'm not sure when I'll have time to write patches for the actual packages myself. Current implementations are naive, but more obviously correct. The package is not yet released on Hackage, I'll do that after the comments, which are warmly welcome! Best regards, Oleg Grenrus [1]: https://github.com/phadej/functor-classes-compat

1 0

Gitter Haskell Community
by Ben Spencer 13 Dec '16

13 Dec '16

Hello all, We have a small group of Haskellers over in our Gitter community chat. If you're inclined, come check us out at https://gitter.im/haskell-chat/Lobby. We have about 40 Haskell enthusiasts so far! Why Gitter you might ask? Gitter was designed for open communities. It's free for unlimited users and you get full access to your chat history. And you only need your Github account to sign up. Plus if we generate enough activity, Gitter will feature Haskell as a suggested community! Best, Ben

10 10

Supporting Haskell.org in 2016
by Adam Foltzer 12 Dec '16

12 Dec '16

Dear Haskellers, A great deal of core infrastructure, including HaskellWiki, Hackage, Hoogle, and build infrastructure for GHC are hosted and managed with the help of donations to haskell.org, from you, the Haskell community. As many of us are in tax jurisdictions where December 31st is a deadline for charitable giving, I’d like to remind you that donations to support these activities are tax-deductible. You can donate online right now through the donate button on the wiki: https://wiki.haskell.org/Donate_to_Haskell.org. Mailing information for checks is also on that page. New for this year, individual donations may be made directly via Paypal rather than the clickandpledge service, and Haskell.org is also can now accept donations through employers via Benevity using the unique ID 475236502. This year we had a successful first Summer of Haskell, offering 8 stipends of $5,500 to students making valuable contributions to our shared tooling and infrastructure such as ghc, ghcjs, and hackage, and engaging them in what we hope becomes a long succession of contributions to open source software. The exciting results are available at https://mail.haskell.org/ pipermail/haskell-cafe/2016-December/125702.html; this work is only made possible by your generous support, and that of the sponsors listed at https://summer.haskell.org/. We also have continued improving our infrastructure, using committee funds to help the development of a new performance tracker for ghc, with the aim of opening this up to a broader range of projects as well. With your support, we hope to continue these activities and more in 2017. Best wishes, Adam Foltzer on behalf of the Haskell.org committee

1 0

A Procedural-Functional Language (WIP)
by Rik Howard 12 Dec '16

12 Dec '16

Dear Haskell Cafe Subscribers on the recommendation of someone for whom I have great respect, I have just subscribed to this list, it having been suggested as being a good place for me to get feedback regarding a project that I have been working on. I am humbled by the level of discussion and it feels to be a very bold step for me to request anybody's time for my words. The linked document is a four-page work-in-progress summary: the length being stipulated, potential novelty being the other main requirement. Given the requirements, the summary necessarily glosses over some details and is not yet, I fear, completely correct. The conclusion is, more or less, the one at which I am aiming; the properties are, more or less, the ones that are needed. http://www.dcs.bbk.ac.uk/~rik/gallery/work-in-progress/document.pdf The work arises from an investigation into functional programming syntax and semantics. The novelty seems to be there but there is too a question as to whether it is simply a gimmick. I try to suggest that it is not but, by that stage, there have been many assumptions so it is hard to be sure whether the suggestion is valid. If anyone has any comments, questions or suggestions, they would be gratefully received. Yours sincerely Rik Howard

15 36

PhD studentships at Leeds
by David Duke 12 Dec '16

12 Dec '16

The School of Computing at the University of Leeds is advertising a number of PhD studentships open to UK, EU and international applicants. Two of the projects are at the overlap between functional programming and visualization, one on performance analysis, one on explaining type inference. Please see the following URL for further information including how to apply: https://engineering.leeds.ac.uk/research-opportunity/201323/research-degree… Closing date: 06/01/2017 --- David Duke T: +44 113 3436800 Professor of Computer Science E: D.J.Duke(a)leeds.ac.uk Head, School of Computing W: www.comp.leeds.ac.uk/scsdjd/

1 0

[Ann] Haskell Ecosystem Proposals
by Alan & Kim Zimmerman 11 Dec '16

11 Dec '16

Earlier this year Simon Peyton Jones wrote about respect [1], and said "It's worth separating two things 1. Publicly debating an issue where judgements differ 2. Using offensive or adversarial language in that debate" There is now a repository[2] for us as a community to have the first kind of discussion about issues that affect the community as a whole. The intention is that this becomes a neutral place where discussion can take place about coordinating the various services offered to the haskell community. This is partly to expose the thinking and constraints on a particular approach, so proponents of other approaches can have a better understanding of how things can evolve. The idea is that through an honest understanding of the various parts we can achieve consensus on how to improve things. If this all sounds a bit handwavy, the first concrete example of this approach is a pull request [3] discussing the management of implicit or speculative version bounds between cabal-install/hackage and stack/stackage. This has reached a point where there is a clearer understanding of the actual problem, and a viable solution must be agreed. The structure of the repository is shamelessly copied from the one for GHC proposals, so the actual process description is way off. It should probably just state that we discuss until consensus is reached if possible, but that we are always open for further discussion. It is up to all of us to make this work. Regards Alan [1] https://mail.haskell.org/pipermail/haskell/2016-September/024995.html [2] https://github.com/haskell/ecosystem-proposals [3] https://github.com/haskell/ecosystem-proposals/pull/1

1 0

what is lens-based parsing?
by Ruben Astudillo 10 Dec '16

10 Dec '16

Dear Cafe I've reading the tutorial for pipes-parse, and I got some references that it supports lens-based parsing. I know lens, yet I don't really know what is that about. Also looking in google doesn't get any detailed blogpost. Can anybody help me out on what is this? -- -- Ruben

2 1

Partial Evaluation & Program Manipulation (PEPM'17): Call for Participation
by Jeremy Yallop 09 Dec '16

09 Dec '16

CALL FOR PARTICIPATION Workshop on PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM 2017) http://conf.researchr.org/home/PEPM-2017 Paris, France, January 16th - 17th, 2017 (co-located with POPL 2017) Registration ------------ http://popl17.sigplan.org/attending/registration Early registration deadline: Saturday 17th Dec 2016 Programme --------- Monday 16th January 09:00-10:00: Keynote Compiling Untyped Lambda Calculus to Lower-Level Code by Game Semantics and Partial Evaluation Neil D. Jones (with Daniil Berezun) 10:30-12:00: Programming languages Lightweight Soundness for Towers of Language Extensions Alejandro Serrano, Jurriaan Hage Detecting code clones with gaps by function applications Tsubasa Matsushita, Isao Sasano PEG Parsing in Less Space Using Progressive Tabling and Dynamic Analysis Fritz Henglein, Ulrik Terp Rasmussen 14:00-15:30: Tutorial and Poster Session Idris, Inside-Out: A Tutorial on Extending Idris in Idris David Christiansen Language-integrated Query with Ordering, Grouping and Outer Joins (poster) Tatsuya Katsushima, Oleg Kiselyov 16:00-17:00: Transformation (part I) Verification of Code Generators via Higher-Order Model Checking Takashi Suwa, Takeshi Tsukada, Naoki Kobayashi, Atsushi Igarashi Interactive data representation migration: Exploiting program dependence to aid program transformation Krishna Narasimhan, Julia Lawall, Christoph Reichenbach Tue 17th January 09:00-10:00: Tutorial Reversible computing from a programming language perspective Robert Glück 10:30-12:00: Types Cost versus Precision for Approximate Typing for Python Levin Fritz, Jurriaan Hage Refining types using type guards in TypeScript Ivo Gabe de Wolff, Jurriaan Hage Predicting Resource Consumption of Higher-Order Workflows Markus Klinik, Jurriaan Hage, Jan Martin Jansen, Rinus Plasmeijer 14:00-15:30: Tutorial Practical Partial Evaluation for Language Implementation with Graal & Truffle Gilles Duboscq 16:00-17:00: Transformation (part II) Functional Parallels of Sequential Imperatives Tiark Rompf, Kevin J. Brown A Functional Reformulation of UnCAL Graph-Transformations: Or, Graph Transformation as Graph Reduction Kazutaka Matsuda, Kazuyuki Asada

1 0

Dockerfile for building ghc8.0 with ubuntu 16.04LTS
by Takenobu Tani 09 Dec '16

09 Dec '16

Hi cafe, I pushed Dockerfile for building ghc8.0 with ubuntu 16.04LTS. (If you need Debian and Arcanist, please use Greg's Dockerfile[1].) Dockerfile for Haskell GHC building https://github.com/takenobu-hs/ghc-build-docker Let's get familiar with ghc building and validating :) [1]: https://github.com/gregwebs/ghc-docker-dev [2]: https://ghc.haskell.org/trac/ghc/wiki/Building Enjoy, Takenobu

1 0

Summer of Haskell 2016 Wrap-Up
by Gershom B 08 Dec '16

08 Dec '16

We wanted to let folks know what happened with all our Summer of Haskell projects, and thank again all those who donated as individuals or sponsored students to make this possible. As a reminder, the accepted projects were announced on reddit at: https://www.reddit.com/r/haskell/comments/4kp6zg/summer_of_haskell_2016_acc… * * * 1) Native Metaprogramming in Haskell This very ambitious project made significant progress, though is not yet ready for a full merge into GHC. A talk and paper on work relating to it were presented at the Haskell Implementors Workshop at ICFP, and a page on the GHC wiki describes the current status. - https://www.youtube.com/watch?v=DSWoGdfYt68 - https://arxiv.org/abs/1610.04799 - https://ghc.haskell.org/trac/ghc/wiki/NativeMetaprogramming 2) GHCVM - A JVM Backend for GHC Again, significant progress made on a very ambitious project, which has now been renamed to “eta”. A talk on the work done was given at the HIW, and the project is considered ready for “hobbyist use”. - https://www.youtube.com/watch?v=G4m7xFVzd50 - https://github.com/typelead/eta 3) Completing the LLVM backend for Accelerate All operators of the LLVM backend are now implemented, and we’re told that the accelerate-llvm project, already usable, will be get a more proper announcement as ready for widespread use real soon now (tm). - https://github.com/AccelerateHS/accelerate-llvm - https://github.com/AccelerateHS/accelerate-llvm/commits?author=ZihengJiang 4) Hackage Improvements A whole raft of usability improvements to hackage (including the long-awaited rollout of reverse dependency tracking, and a very usable package browser interface) are undergoing final code review and polish in a PR before being rolled out. The student’s blog contains more information about what’s on the way. - http://sooryanarayan.me/blog/hsoc-testimonial/ 5) Derivable Storable and Prim instances This work resulted in both a package (usable today) and a plugin to improve the performance of the derived code. Updates on the decisions made and work done were posted to the numerical-haskell group - https://hackage.haskell.org/package/derive-storable - http://hackage.haskell.org/package/derive-storable-plugin - https://groups.google.com/forum/#!forum/numericalhaskell 6) Visual functional block-based programming language for CodeWorld This work went well and is described on the student’s blog. It is usable today at https://code.world/blocks and apparently has already begun to be integrated into CodeWorld lesson plans. - http://stefanj.me/funblocks/ - https://code.world/blocks 7) Jupyter for GHCJS Apparently this ran into a far amount of difficulties and didn’t make significant progress, though not for lack of effort. The student is anticipated to write up an experience report describing some of the problems encountered and how others might work around them in the future. 8) Live Profiling and Performance Monitoring Server A lot of work was accomplished on various fronts here. A number of changes to the GHC RTS are in review and pending merge. A tool has been written to take advantage of the newly available information. And various other small packages that met needs along the way were extracted and contributed to hackage. A fuller write-up of progress and future work is available at the student’s blog. - https://phabricator.haskell.org/D2522 - https://github.com/NCrashed/live-profile-monitor - http://ncrashed.github.io/blog/posts/2016-09-11-hsoc-results.html * * * Apologies for the delays in assembling this information -- as they say, man plans, the fates laugh. Thanks to all our students for their dedicated work and contributions to the ecosystem. We hope to see much more from all of you in the future. And thanks to all our mentors for donating their time to guide, teach, and make this possible. And a very special thanks to Edward Kmett for co-ordinating much of the administrative work here, as well as fundraising towards this great Summer of Haskell. * * * Sponsors (listed on summer.haskell.org) - haskell.org kicked things off this year by funding a student and organizing the Summer of Haskell. - Awake Networks is building a next generation network security and analytics platform. They are a proud sponsor of the Summer of Haskell and contribute broadly to the Haskell community. - Haskell Book is a proud sponsor of the Summer of Haskell and provides a complete and up-to-date resource for learning Haskell, suitable whether you're completely new to Haskell or are at an intermediate level and want to deepen your understanding. - YOW! Australia is a proud sponsor of the Summer of Haskell and organizes conferences throughout Australia. - Chris Smith volunteered to fund two students to work on CodeWorld in particular. - Edward Kmett and Gershom Bazerman volunteered to personally fund a student project. Best, Gershom Bazerman Haskell.org Committee

1 0

Bits.bitSize
by ALeX Kazik 08 Dec '16

08 Dec '16

Hi, I think it would be a good idea to provide a default implementation for bitSize, example: bitSize b = fromMaybe (error "bitSize is undefined") (bitSizeMaybe b) The advantage is that from now on new instances of Bits no longer need to define bitSize. And once bitSize has been removed there will be no errors about it not being a method of class Bits. ALeX.

1 0

ANN: Free hands-on Haskell workshop in Augsburg, Germany on 2012-12-17 [with German videos]
by Ingo Blechschmidt 08 Dec '16

08 Dec '16

Dear lovers of generalized abstract nonsense, this mail is directed at Haskell neophytes, novices, and advanced learners living near Augsburg, Germany; and at Haskell aficionados living all over the world but speaking German. On 2012-12-17, we -- the Curry Club Augsburg -- will organize a free all-day hands-on workshop on Haskell. Join us in the morning without having seen a single line of Haskell code and leave with working knowledge of Haskell's basics. If you already know a bit of Haskell, then learn your ways with Haskell's vast library ecosystem, how to structure bigger programs, how to check your code for correctness, and how to write parsers/websites/numerical simulations/user interfaces/two- and three-dimensional games. So that we don't exceed our capacity for individual mentoring during the workshop, a mandatory but nonbinding registration is necessary. [1] In case that you want to dive deeper into Haskell and other functional languages after having participated in the workshop, you are invited to join us at our monthly meetings. There are typically two to three talks on a wide range of topics of interest to Haskell programmers, such as latest news from the Kmettiverse, glimpses into formal logic and proof assistants like Isabelle, and introductions to the category-theoretic background of freer monads or to infinite-time Turing machines and the effective topos. All of our talks are recorded [2]. Our workshop documents are CC-licensed [3]. Feel free to copy them, modify them, and host Haskell workshops at other places! Cheers, Ingo of Augsburg's Curry Club [1] http://curry-club-augsburg.de/posts/2016-12-06-dritter-workshop.html [2] https://www.youtube.com/channel/UCKV6TVS9DWaEix6l3_l457Q [3] https://rawgit.com/curry-club-aux/haskell-workshop/gh-pages/uebung.pdf https://rawgit.com/curry-club-aux/haskell-workshop/gh-pages/uebung2.pdf http://curry-club-augsburg.de/posts/2015-10-27-monaden-in-haskell.html (All hail the monad tutorial fallacy. English translation by Harry Garrood at https://gist.github.com/iblech/429652a31b05e408262b.)

1 0

Injective type family on a sub domain
by Guillaume Bouchard 08 Dec '16

08 Dec '16

Hi. I have the following GADT : ----------------------------- type family Or a b where Or 'False 'False = 'False Or _ _ = 'True data Expr t where Add :: Expr t -> Expr t' -> Expr (Or t t') Lit :: Int -> Expr 'False Var :: Expr 'True ---------------------- The idea is that if the `Expr` contains a sub `Var`, its type is `Expr 'True`, else it is `Expr 'False`. I now want to evaluate my expression, something like that : -------------- eval :: Expr t -> Int eval (Lit i) = i eval (Add a b) = eval a + eval b eval Var = error "Cannot evaluate expression with variable" ---------------- Using the GADT I previously defined, I'm tempted to remove the impossible "Var" case with : --------------- eval' :: Expr 'False -> Int eval' (Lit i) = i eval' (Add a b) = eval' a + eval' b ---------------- However this does not typecheck because GHC cannot deduce that `a` and `b` are `~ Expr 'False`. Because the type family `Or` is not injective. The wiki https://ghc.haskell.org/trac/ghc/wiki/InjectiveTypeFamilies classifies injectives types families in three categories, but I don't think my `Or` appears in any of them. Actually `Or` is injective only if `Or t t' ~ 'False` and in this case, we can deduce that `t ~ 'False` and `t' ~ 'False`. I qualify it as a "partialy injective type family". The type checker does not know that, hence my code does not compile. Is there a solution, other than writing a custom type checker plugin? Is there a way to provide the inverse type family function, something such as: type family InverseOr a where InverseOr 'False = ('False, 'False) Thank you. -- G.

4 7

Re: [Haskell-cafe] Gitter Haskell Community
by Ben Spencer 08 Dec '16

08 Dec '16

I think it's important to recognize that users have different tastes and needs. Additionally, Gitter allows you to view the chat channel if you wish. It's also something that's publicly viewable and searchable from Gitter explore. It doesn't require the odd signup process that Slack has implemented. I can actually see my chat history for more than 2 days! But beyond that if you like Slack and its community then more power to you. We can certainly have a difference of opinion and preferences. -Ben On Dec 07, 2016, at 12:09 PM, Michael Walker <mike(a)barrucadu.co.uk> wrote: The Haskell slack seems to be working well, so regardless of the suitability of slack to open communities or not, I don't really see the advantage of fragmenting the community even further. Why would someone pick gitter over the two existing platforms that have thousands of users? They would be intentionally limiting the help they can get. On 7 December 2016 at 17:07, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Hey Chris, As I've mentioned Slack isn't a good choice for open communities. It's really designed for businesses. On Dec 07, 2016, at 11:52 AM, Christopher Allen <cma(a)bitemyapp.com> wrote: For that, there's http://fpchat.com/ which is an established Slack community. The #haskell channel alone has 1,208 people in it right now. On Wed, Dec 7, 2016 at 10:50 AM, Tomas Carnecky <tomas.carnecky(a)gmail.com> wrote: Usability matters. It's easier to tell people to open a browser window and point them at a URL than tell them to download an IRC chat client and how to connect to the server and... On Wed, Dec 7, 2016 at 5:41 PM William Yager <will.yager(a)gmail.com> wrote: What are the advantages of this over the #haskell IRC on freenode? It's very active, usually with over 1500 nicks at any given time. I generally prefer IRC to any of these hip web chat solutions because IRC is client-agnostic and very rugged against companies folding or deciding they don't want to host a project any more. Basically the only way to kill an IRC channel is through social attrition, whereas any social value built up in hosted chat services might disappear overnight. The one major advantage of hosted chats over IRC is that they work better with mobile users, but I don't think that's very relevant for haskell dev. Will On Wed, Dec 7, 2016 at 7:34 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Why Gitter you might ask? _______________________________________________ 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. -- Chris Allen Currently working on http://haskellbook.com _______________________________________________ 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. -- Michael Walker (http://www.barrucadu.co.uk)

9 11

Re: [Haskell-cafe] Gitter Haskell Community
by Justin Wood 07 Dec '16

07 Dec '16

Ben, Please make sure that you use reply all in the future so that the message does not go just to me. For everyone else on the list, this was the message > That comes back to usability. The client functions but it is not appealing. Personal taste, I suppose. I agree that freenode webchat is not the most appealing piece of software, but there are plenty of web based IRC clients. I'm sure there are some that are appealing. On Wed, Dec 7, 2016 at 11:56 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: > That comes back to usability. The client functions but it is not > appealing. Personal taste, I suppose. > > On Dec 07, 2016, at 11:55 AM, Justin Wood <justin.k.wood(a)gmail.com> wrote: > > > It's easier to tell people to open a browser window and point them at a > URL > > You could always point someone to https://webchat.freenode.net/ or any > other web based IRC client. > > On Wed, Dec 7, 2016 at 11:51 AM, Christopher Allen <cma(a)bitemyapp.com> > wrote: > >> For that, there's http://fpchat.com/ which is an established Slack >> community. The #haskell channel alone has 1,208 people in it right >> now. >> >> On Wed, Dec 7, 2016 at 10:50 AM, Tomas Carnecky >> <tomas.carnecky(a)gmail.com> wrote: >> > Usability matters. It's easier to tell people to open a browser window >> and >> > point them at a URL than tell them to download an IRC chat client and >> how to >> > connect to the server and... >> > >> > On Wed, Dec 7, 2016 at 5:41 PM William Yager <will.yager(a)gmail.com> >> wrote: >> >> >> >> What are the advantages of this over the #haskell IRC on freenode? It's >> >> very active, usually with over 1500 nicks at any given time. >> >> >> >> I generally prefer IRC to any of these hip web chat solutions because >> IRC >> >> is client-agnostic and very rugged against companies folding or >> deciding >> >> they don't want to host a project any more. Basically the only way to >> kill >> >> an IRC channel is through social attrition, whereas any social value >> built >> >> up in hosted chat services might disappear overnight. >> >> >> >> The one major advantage of hosted chats over IRC is that they work >> better >> >> with mobile users, but I don't think that's very relevant for haskell >> dev. >> >> >> >> Will >> >> >> >> On Wed, Dec 7, 2016 at 7:34 AM, Ben Spencer < >> ben.richard.spencer(a)me.com> >> >> wrote: >> >>> >> >>> Why Gitter you might ask? >> >> >> >> _______________________________________________ >> >> 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. >> >> >> >> -- >> Chris Allen >> Currently working on http://haskellbook.com >> _______________________________________________ >> 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

Re: [Haskell-cafe] Gitter Haskell Community
by Ben Spencer 07 Dec '16

07 Dec '16

Hey Chris, As I've mentioned Slack isn't a good choice for open communities. It's really designed for businesses. On Dec 07, 2016, at 11:52 AM, Christopher Allen <cma(a)bitemyapp.com> wrote: For that, there's http://fpchat.com/ which is an established Slack community. The #haskell channel alone has 1,208 people in it right now. On Wed, Dec 7, 2016 at 10:50 AM, Tomas Carnecky <tomas.carnecky(a)gmail.com> wrote: Usability matters. It's easier to tell people to open a browser window and point them at a URL than tell them to download an IRC chat client and how to connect to the server and... On Wed, Dec 7, 2016 at 5:41 PM William Yager <will.yager(a)gmail.com> wrote: What are the advantages of this over the #haskell IRC on freenode? It's very active, usually with over 1500 nicks at any given time. I generally prefer IRC to any of these hip web chat solutions because IRC is client-agnostic and very rugged against companies folding or deciding they don't want to host a project any more. Basically the only way to kill an IRC channel is through social attrition, whereas any social value built up in hosted chat services might disappear overnight. The one major advantage of hosted chats over IRC is that they work better with mobile users, but I don't think that's very relevant for haskell dev. Will On Wed, Dec 7, 2016 at 7:34 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Why Gitter you might ask? _______________________________________________ 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. -- Chris Allen Currently working on http://haskellbook.com

2 1

Re: [Haskell-cafe] Gitter Haskell Community
by Ben Spencer 07 Dec '16

07 Dec '16

Hey William, I'll speak from my experience. I've noticed that the developers I work with (mostly younger developers) have embraced tech like Github, Slack, and Gitter. When I first tried Slack I didn't like it much but now I understand the appeal. I remember trying IRC a long time ago. It seemed to work for the time but for whatever reason I didn't take to it. This part is my opinion, but if a community like Haskell wants to gain wider appeal we have to meet new people where they are at. Most people know about Github and like Github. A solution like Gitter integrates nicely. Slack isn't a good option because it's designed for businesses in mind. The chat history is limited and you have to pay for extra features. IRC is a bit aged. It doesn't make it bad but newer developers are interested in the new shiny technology. I've also seen a few posts that in order to get it to work well (ie having a chat history) you have to have a hosted service. That's overhead I rather not have. But more importantly, we should meet the community where they're at and that's on Github. Best, Ben Spencer On Dec 07, 2016, at 11:41 AM, William Yager <will.yager(a)gmail.com> wrote: What are the advantages of this over the #haskell IRC on freenode? It's very active, usually with over 1500 nicks at any given time. I generally prefer IRC to any of these hip web chat solutions because IRC is client-agnostic and very rugged against companies folding or deciding they don't want to host a project any more. Basically the only way to kill an IRC channel is through social attrition, whereas any social value built up in hosted chat services might disappear overnight. The one major advantage of hosted chats over IRC is that they work better with mobile users, but I don't think that's very relevant for haskell dev. Will On Wed, Dec 7, 2016 at 7:34 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Why Gitter you might ask?

1 0

Re: [Haskell-cafe] Gitter Haskell Community
by Ben Spencer 07 Dec '16

07 Dec '16

Hello Tomas, I agree usability does matter. On Dec 07, 2016, at 11:55 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Hello Tomas, I agree usability does matter. On Dec 07, 2016, at 11:51 AM, Tomas Carnecky <tomas.carnecky(a)gmail.com> wrote: Usability matters. It's easier to tell people to open a browser window and point them at a URL than tell them to download an IRC chat client and how to connect to the server and... On Wed, Dec 7, 2016 at 5:41 PM William Yager <will.yager(a)gmail.com> wrote: What are the advantages of this over the #haskell IRC on freenode? It's very active, usually with over 1500 nicks at any given time. I generally prefer IRC to any of these hip web chat solutions because IRC is client-agnostic and very rugged against companies folding or deciding they don't want to host a project any more. Basically the only way to kill an IRC channel is through social attrition, whereas any social value built up in hosted chat services might disappear overnight. The one major advantage of hosted chats over IRC is that they work better with mobile users, but I don't think that's very relevant for haskell dev. Will On Wed, Dec 7, 2016 at 7:34 AM, Ben Spencer <ben.richard.spencer(a)me.com> wrote: Why Gitter you might ask? _______________________________________________ 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

State of records in Haskell
by Øystein Kolsrud 07 Dec '16

07 Dec '16

Hi! I recently had a look at a talk by Simon Peyton Jones on lenses (https://skillsmatter.com/skillscasts/4251-lenses-compositional-data-access-…) and happened to notice that, at the very end, he mentions that there were changes going into GHC 7.10 that would make it possible to use the same field name for multiple record types. I was searching around a little for more information on this, but had a hard time finding what I was looking for and was hoping that someone here could give me a pointer. What does GHC support in this domain at the moment, and are there any particular flags I need to use in order to use that functionality? Best regards, Øystein Kolsrud

2 1

CFP Bx 17: 6th International Workshop on Bidirectional Transformations
by Meng Wang 07 Dec '16

07 Dec '16

CFP Bx 17: 6th International Workshop on Bidirectional Transformations CALL FOR PAPERS Sixth International Workshop on Bidirectional Transformations (Bx 2017) Uppsala, Sweden (Saturday April 29th, as part of ETAPS 2017) http://bx-community.wikidot.com/bx2017:home Bidirectional transformations (bx) are a mechanism for maintaining the consistency of at least two related sources of information. Such sources can be relational databases, software models and code, or any other document following standard or ad-hoc formats. Bx are an emerging topic in a wide range of research areas, with prominent presence at top conferences in several different fields (namely databases, programming languages, software engineering, and graph transformation), but with results in one field often getting limited exposure in the others. Bx 2017 is a dedicated venue for bx in all relevant fields, and is part of a workshop series that was created in order to promote cross-disciplinary research and awareness in the area. As such, since its beginning in 2012, the workshop has rotated between venues in different fields. IMPORTANT DATES - Abstract submission: 20 Jan 2017 - Paper submission: 27 Jan 2017 - Author notification: 17 Feb 2017 - Camera-ready version: 1 March 2017 - Workshop date: 29 April 2017 AIMS AND TOPICS The aim of the workshop is to bring together researchers and practitioners, established and new, interested in bx from different perspectives, including but not limited to: - data and model synchronization - view updating - inter-model consistency analysis and repair - data/schema (or model/metamodel) co-evolution - coupled software/model transformations - inversion of transformations and data exchange mappings - domain-specific languages for bx - analysis and classification of requirements for bx - bridging the gap between formal concepts and application scenarios - analysis of efficiency of transformation algorithms and benchmarks - survey and comparison of bx technologies - case studies and tool support PAPER CATEGORIES Submissions to Bx 2017 can be: - Regular papers (up to 15 pages) - in-depth presentations of novel concepts and results - applications of bx to new domains - survey papers providing novel comparisons between existing bx technologies and approaches - case studies - Tool papers (up to 8 pages) - guideline papers presenting best practices for employing a specific bx approach (with a specific tool) - presentation of new tools or substantial improvements to existing ones - qualitative and/or quantitative comparisons of applying different bx approaches and tools - Short papers (up to 4 pages) - work in progress - small focused contributions - position papers and research perspectives - critical questions and challenges for bx - Talk proposals (up to 2 pages) - proposed lectures about topics of interest for bx - existing work representing relevant contributions for bx - promising contributions that are not mature enough to be proposed as papers of the other categories All papers are expected to be self-contained and well-written. Tool papers are not expected to present novel scientific results, but to document artifacts of interest and share bx experience/best practices with the community. Short papers should primarily provoke interesting discussion at the workshop and will not be held to the same standard of maturity as regular papers. Talk proposals are expected to present works of particular interest for the community and that are worth a talk slot at the workshop. We strongly encourage authors to ensure that any (variants of) examples are present in the bx example repository at the time of submission, and for tool papers, to allow for reproducibility with minimal effort, either via a virtual machine (e.g. via Share - http://share20.eu) or a dedicated website with relevant artifacts and tool access. SUBMISSION GUIDELINES Submitted papers must follow the CEUR one column style available at http://ceur-ws.org/Vol-XXX/samplestyles/. Papers must be submitted via the EasyChair system: https://www.easychair.org/conferences/?conf=bx2017. Submissions not complying with the above guidelines may be excluded from the reviewing process without further notice. If a paper is accepted, one author of the paper is expected to participate in the workshop to present it. Authors of accepted tool papers are also expected to be available to demonstrate their tool at the event. PROCEEDINGS AND SPECIAL ISSUE The workshop proceedings, including all accepted papers (except talk proposals), will be published electronically by CEUR (http://ceur-ws.org) Authors of accepted papers (of all categories except talk proposal) that have high-quality and the potential to be extended into journal articles will be invited to submit a revised and extended version of their paper to an expected special issue of the Journal of Object Technology (http://www.jot.fm) these papers will then be subject to a careful reviewing and selection process according to the scientific standards of the Journal of Object Technology. PROGRAM CO-CHAIRS - Romina Eramo, University of L'Aquila, Italy - Michael Johnson, Macquarie University, Australia PROGRAM COMMITTEE MEMBERS - Anthony Anjorin, University of Paderborn, Germany - Soichiro Hidaka, Hosei University, Japan - Max E. Kramer, Karlsruhe Institute of Technology, Germany - James McKinna, University of Edinburgh, UK - Hugo Pacheco, University of Minho, Portugal - Alfonso Pierantonio, University of L'Aquila, Italy - Andy Schürr, Technical University of Darmstadt, Germany - Daniel Strüber, Universität Koblenz-Landau, Germany - James Terwilliger, Microsoft, USA - Meng Wang, University of Kent, UK - Bernhard Westfechtel, Universität Bayreuth, Germany - Manuel Wimmer, Vienna University of Technology, Austria +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Dr. Meng Wang | Lecturer in Computer Science School of Computing | University of Kent | Canterbury, Kent, CT2 7NF, UK m.w.wang(a)kent.ac.uk<mailto:m.w.wang@kent.ac.uk> | www.cs.kent.ac.uk/~mw516<http://www.cs.kent.ac.uk/~mw516> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1 0

Qualified imports and REPL output in GHCi 8.0.1
by Atrudyjane 07 Dec '16

07 Dec '16

When I do a qualified import such as: λ> import qualified Data.Bool then query a type, this is the output. λ> :t Data.Bool.bool Data.Bool.bool :: a -> a -> Bool -> a Was expecting: λ> :t Data.Bool.bool Data.Bool.bool :: a -> a -> Data.Bool.bool -> a I experimented with changing the -fno-implicit-import-qualified flag and the result was the same. Is there an option that needs to be set to show the expected behavior? Regards, Andrea Sent with [ProtonMail](https://protonmail.com) Secure Email.

2 2

Use of errorWithoutStackTrace in the Prelude
by Alexis King 07 Dec '16

07 Dec '16

Hello, I noticed that the partial functions in the Prelude use errorWithoutStackTrace instead of `error` to provide their error messages, which produces significantly worse error messages. I stumbled into this when a coworker of mine had trouble tracking down a use of `head` that was throwing an exception, but didn’t include any information about where it was in the source. What exactly is the rationale for this? Is it to avoid the performance penalty of passing around the implicit parameter? That seems relatively unlikely, since the performance hit seems trivial, but perhaps it’s to avoid breaking tests that depend on error messages? I think it would be nice for Prelude-provided functions to be informative by default, so the change seems worth it to me, but I’m wondering if there’s something I’ve overlooked. Also, if the answer really is “no, errorWithoutStackTrace is correct”, is the expectation that people will use -prof if they want stacks? This seems a bit frustrating to a newcomer who might not understand anything more complicated than running `stack test` and might not be able to figure out how to pass the right options (especially since options need to be passed both at compile-time and at runtime). Thanks, Alexis

2 2

Re: [Haskell-cafe] stack setup errors when user name has accents
by Andre Fernandes 06 Dec '16

06 Dec '16

> > This was due to a bug in the yaml package, apologies. It's been patched, > and the next version of Stack will have the bugfix. I believe the next > version will be released in the next few days, but if you're able to build > from master, you can use that. > Thanks a lot for your answer, it's good to know that soon the new Stack version will solve it. > > Here's the original issue, which includes a link to a temporary workaround: > https://github.com/commercialhaskell/stack/issues/2491 > > I'll take a look at that. > On Mon, Dec 5, 2016 at 8:13 PM, Andre Fernandes <fernand...@gmail.com > <javascript:>> wrote: > >> I am new in Haskell, and I am trying to use stack in my "Windows 10" >> machine to study a little more. >> >> Stack installed nicely, but when I run "stack setup" at the command >> prompt I get the following error: >> >> *"Could not parse 'C:\Users\Andr├®\AppData\Roaming\stack\config.yaml':* >> *InvalidYaml (Just (YamlException "Yaml file not found: >> C:\\Users\\Andr\233\\AppData\\Roaming\\stack\\config.yaml"))* >> >> *See http://docs.haskellstack.org/en/stable/yaml_configuration/ >> <http://docs.haskellstack.org/en/stable/yaml_configuration/>."* >> >> My name is "André" with an accent, and that's the problem, it can not >> find config.yaml at my windows user directory. Is there a way to solve this >> problem, maybe force stack to look into another folder, or something else? >> >> My windows command prompt encoding is 850, I do not not know if this info >> could help. >> >> Thanks in advance for any answer, >> André. >> >> _______________________________________________ >> 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

stack setup errors when user name has accents
by Andre Fernandes 06 Dec '16

06 Dec '16

I am new in Haskell, and I am trying to use stack in my "Windows 10" machine to study a little more. Stack installed nicely, but when I run "stack setup" at the command prompt I get the following error: *"Could not parse 'C:\Users\Andr├®\AppData\Roaming\stack\config.yaml':* *InvalidYaml (Just (YamlException "Yaml file not found: C:\\Users\\Andr\233\\AppData\\Roaming\\stack\\config.yaml"))* *See http://docs.haskellstack.org/en/stable/yaml_configuration/."* My name is "André" with an accent, and that's the problem, it can not find config.yaml at my windows user directory. Is there a way to solve this problem, maybe force stack to look into another folder, or something else? My windows command prompt encoding is 850, I do not not know if this info could help. Thanks in advance for any answer, André.

2 1

Following-up on the laziness thread on Reddit
by Saurabh Nanda 06 Dec '16

06 Dec '16

Thoughts on this particular comment - https://www.reddit.com/r/haskell/comments/5fyg9e/how_important_is_laziness_… - from core GHC hackers would be very interesting and enlightening. -- Saurabh.

1 0

Call for Haskell.org Committee Nominations
by Gershom B 05 Dec '16

05 Dec '16

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 four members of our committee due for retirement -- Adam Foltzer, Nicolas Wu, Andres Loeh, and Edward Kmett (who is stepping down early). As per our bylaws, three of the slots will be for regular three year terms, and one will be a short one year term to fill out the remainder of Edward's. To nominate yourself, please send an email to committee at haskell.org by December 2, 2016. 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. Best, Gershom Bazerman

2 2

[course announcement] Haskell for Life
by Sergiu Ivanov 05 Dec '16

05 Dec '16

Dear Haskell Cafe, This year I have taught and will teach a short course introducing people to Haskell. I realised that such a course might interest the subscribers of this list, so here is the course page, with all course materials (CC-BY licence): http://lacl.fr/~sivanov/doku.php?id=en:haskell_for_life Any feedback is welcome. (I will teach the next instance of the course in the following two weeks in Chișinău, Republic of Moldova, so if you happen to be around, don't hesitate to come by and give me a wink IRL ;-) ) -- Sergiu

1 0

Fearing Haskell
by Henk-Jan van Tuyl 03 Dec '16

03 Dec '16

L.S., IBM's Watson can analyze web pages, see https://alchemy-language-demo.mybluemix.net/ . If I feed it the URL https://wiki.haskell.org/Haskell , Watson states that this page is about a person called Haskell, with a fearful sentiment. With the URL https://en.wikipedia.org/wiki/Haskell_(programming_language) , there is both joy and sadness in Haskell. :-) Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

monad-coroutine alternatives
by Alex 02 Dec '16

02 Dec '16

Hello, Are there any data structures isomorphic to Coroutine[0] available on Hackage? -- Alex [0] https://hackage.haskell.org/package/monad-coroutine-0.9.0.3/docs/Control-Mo…

2 2

An idea on extensible effects (anonymous record)
by winter 30 Nov '16

30 Nov '16

Hi everyone! First of all, i don't know if this idea is already being discussed so if there's a discussion on this i'd like to follow. To illustrate, first i want to create a class like: class Has a t where get :: t -> a then i define instance for simple product type such as tuple: instance Has a (a, b) where get (a, _) = a instance Has b (a, b) where get (_, b) = b ... You can image i will use th to make lots of instance for difference tuple size. Now if i want an extensible reader, i use Has class like this: someReader :: Has Int t => Reader t Int someReader = do x <- ask return $ get x + 1 Then i can run it with any tuple with an Int field like: runReader someReader (0 :: Int, "adad”) -- 1 This typeclass almost solved all problem of my network application: sometime’s i want ensure a logger, a sql backend and a http client pool in my monad’s environment, but i don’t want to fix my environment into a record. We can add a set :: a -> t -> t, or use lens to define Has, so that we can have extensible states. We can also use Tagged to achieve something like: (Has (Tagged “SqlBackEndOne” SqlBackEnd) t, Has (Tagged “SqlBackEndTwo" SqlBackEnd) t) => Reader t () It there a library doing this, maybe in lens? or there’re some drawbacks i didn’t notice? All ideas are welcomed! Cheers~ Winter

4 8