- Haskell-Cafe - Haskell.org

(Sample) bioinformatics applications
by Vasili I. Galchin 22 Oct '18

22 Oct '18

Hello, Do any of these beasts exist for reference? Regards, Vasily

1 0

Well typed OS
by Yotam Ohad 22 Oct '18

22 Oct '18

Hi, In the last couple of days, I've been toying with the thought of an operating system in which programs (or more accurately, any process) has a distinct type which limits its use of the machine. For example, `echo` (String -> String) won't be able to print an output without a second program which would handle changing stdout. I think it could "break down" the IO monad into other structures that are better at specifying what is changing: A file is read / memory written / etc. I do, however, not sure how to incorporate drivers (which handles IO and external devices) into this. Giving them an `IO a` type feels like cheating. I would be much cooler if there was a way to treat them like the `echo` function from earlier. What are your thoughts/suggestions? I'll be happy to hear them. Yotam

13 26

Why is the Cabal User's Guide left outdated?
by Yuji Yamamoto 20 Oct '18

20 Oct '18

Getting interested in the features since Cabal 2.2 (esp. common stanzas), I looked up with the User's Guide <https://www.haskell.org/cabal/users-guide/>, which is (and should be) listed in the search result first, but can't find because the User's Guide is still about Cabal 2.0. Why is it left outdated? Actually User's Guide (HEAD) <https://cabal.readthedocs.io/en/latest/> is kept updated, but it's hard to find, and can include some information too new to release. Thanks in advance. -- 山本悠滋 twitter: @igrep GitHub: https://github.com/igrep GitLab: https://gitlab.com/igrep Facebook: http://www.facebook.com/igrep Google+: https://plus.google.com/u/0/+YujiYamamoto_igrep

2 2

"Update
by Nikita Fufaev 20 Oct '18

20 Oct '18

-- Nikita Fufaev, +7 999 825-95-07

1 0

BOB - Call for Contributions 2019
by Matthias Fischmann 20 Oct '18

20 Oct '18

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

1 0

Fwd: [Haskell] Help inform GHC's development priorities
by Takenobu Tani 19 Oct '18

19 Oct '18

(It is sending to the correct address of haskell-cafe ML.) ---------- Forwarded message --------- From: Ben Gamari <ben(a)well-typed.com> Date: Fri, Oct 19, 2018 at 4:45 AM Subject: [Haskell] Help inform GHC's development priorities To: GHC developers <ghc-devs(a)haskell.org>, <haskell(a)haskell.org>, Haskell Cafe <haskell-cafe(a)googlegroups.com>, GHC users < glasgow-haskell-users(a)haskell.org> tl;dr. Please a take a minute to express your thoughts on GHC's development priorities via this survey [1]. Hello everyone, The GHC developers want to ensure that we are working on problems that of most importance to you, the Haskell community. To this end we are surveying the community [1], asking how our users interact with GHC and which problems need to be addressed most urgently. We hope you will take a few minutes to give us your thoughts [1]. Thanks in advance for your time and, finally, thanks to the financial supporters that make our work GHC possible. Cheers, - Ben and the rest of the GHC developers [1] https://docs.google.com/forms/d/e/1FAIpQLSdh7sf2MqHoEmjt38r1cxCF-tV76OFCJqU… _______________________________________________ Haskell mailing list Haskell(a)haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell

1 0

ANN: Extrapolate: generalized QuickCheck-style counterexamples.
by Rudy Matela 17 Oct '18

17 Oct '18

Hello Haskell-Café, A new version of Extrapolate is out: v0.3.5. Since the last announcement here improvements have been made in performance and stability. In addition, the IFL revised accepted paper is finally out (see end of the e-mail). For those who don't know Extrapolate, it is a property testing library capable of reporting generalized counterexamples to properties. Here is a simple example: $ 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 The above property not only fails for the list `[0,0]` but also for any list of the form `x:x:_`. This hints that the above property fails whenever the argument list has repeated elements. The above example is perhaps artificial: the property is obviously wrong! But it does illustrate what Extrapolate is able to produce: aside from the fully defined counterexample it reports a conjectured generalization with some parts of the counterexample replaced by variables or holes. Generalization is particularly helpful when dealing with bigger counterexamples. The following fully-defined counterexample to one of XMonad's properties StackSet { current = Screen { workspace = Workspace { tag = 0, layout = 0, stack = Just ( Stack { focus = 'a', up = "", down = "" } ) }, screen = 0, screenDetail = 0 }, visible = [], hidden = [], floating = fromList [] } is reported by Extrapolate alongside a much simpler generalization: StackSet (Screen (Workspace _ _ (Just _)) _ _) _ _ _ Full details for the above example are given in the research paper. Get Extrapolate with: $ cabal install extrapolate See the Haddock documentation and the project README for more details. I'm interested in input from the Haskell community about Extrapolate. Please let me know if it works (or not) for you. Links: * Research paper (link 1): https://matela.com.br/paper/extrapolate.pdf * Research paper (link 2): https://dl.acm.org/citation.cfm?id=3205371 * Hackage: https://hackage.haskell.org/package/extrapolate * GitHub: https://github.com/rudymatela/extrapolate Best Regards, Rudy

1 0

ANN: DBFunctor – Functional Data Management / ETL Data Processing in Haskell
by Nikos Karagiannidis 16 Oct '18

16 Oct '18

Dear all, I am pleased to announce the release on Hackage of a new Haskell ETL Library, namely DBFunctor-0.1.0.0. (“ETL” stands for Extract Transform and Load and is the standard technology for accomplishing data management tasks in Data Warehouses / Data Marts and in general for data migrations, or for preparing data for any analytic purpose (Ad hoc queries, data exploration/data analysis, Reporting and Business Intelligence, feeding Machine Learning algorithms, etc.)) Version 0.1.0.0 can be used for **in-memory** data processing without the need of some external database. It is just a Haskell library linked in your Haskell program that enables full SQL functionality over tabular data (e.g., CSV files) but also the ability to write a full ETL data processing flow. Key features of this release are: 1. ** Julius DSL ** : A Type-Level Embedded Domain Specific Language (EDSL) for ETL 2. Supports all known relational algebra operations 3. Implements the ETL Mapping and other typical ETL constructs and operations 4. Applicable to all kinds of tabular data 5. In-memory, database-less data processing For more information please check out the project homepage: https://github.com/nkarag/haskell-DBFunctor Also there is a tutorial that can help you to easily get started with Julius DSL: https://github.com/nkarag/haskell-DBFunctor/blob/master/doc/JULIUS-TUTORIAL… * Learn how to implement your ETL flows with Julius DSL * Learn how to implement common ETL operations (e.g., append a delta to some target table, or create a surrogate key column etc.) * Build your own aggregate or analytic functions (e.g., string_agg, or a montlhy running total) * Express complex queries with Julius (equivalent to the WITH-clause in SQL) * and many more ... For any issues/problems with the DBFunctor package please open an issue on github. Happy data processing! Thank you. Best Regards, Nikos

1 0

Re: [Haskell-cafe] Impossible types [was [Haskell-prime]: A question about run-time errors when class members are undefined]
by Anthony Clayden 15 Oct '18

15 Oct '18

Transferring from https://mail.haskell.org/pipermail/haskell-prime/2018-October/004396.html Second instalment. On Sat, 13 Oct 2018 at 4:04 AM, <camarao(a)dcc.ufmg.br> wrote: > ... > Ambiguity should be a property of an expression, defined as > follows: if a constraint set C on the constrained type C∪D⇒t of > an expression has unreachable variables, then satisfiability is > tested for C (a definition of reachable and unreachable type > variables is at the end of this message), and: > > - if there is a single unifying substitution of C with the set > of instances in the current context (module), then C can be > removed (overloading is resolved) and C∪D⇒t 'improved' to > D⇒t; > > - otherwise there is a type error: ambiguity if there are two > or more unifying substitutions of C with the set of instances > in the current context (module), and unsatisfiability > otherwise. > > 2. Allow instances to be imported (all instances are assumed to be > exported): > > import M (instance A τ₁ ⋯ τₙ , … ) > > specifies that the instance of τ₁ ⋯ τₙ for class A is > imported from M, in the module where the import clause > occurs. > > In case of no explicit importation, all instances remain > imported, as currently in Haskell (in order that well-typed > programs remain well-typed). > Consider some typical Read instances from the Haskell Prelude > instance Read a => Read [a] where ... > instance Read a => Read (Maybe a) where ... Suppose I have `show . read` where the 'piggy in the middle' type is unreachable (by your definition below); but I want it to be taken as `(Maybe [Int])`. Then I arrange my imports of instances to make visible only ... what? `(Maybe a)` ? Then how do I read the `[a]`? The only instance in scope is `(Maybe a)`. `(Maybe [Int])` ? Then how do I decompose the structure to call the overloads for `read` of the list and of the `Int`? Instance `(Maybe a)` is not in scope, neither is `[a]` nor `Int`. And what if in the same module/same scope I want `show . read` where 'piggy in the middle' is `[Maybe Int]` or `(Maybe [Bool])` ? Then instead of `Read`, I could create a whole swag of specialised classes/methods: ReadMaybeListInt, ReadListMaybeInt, ReadMaybeListBool, ... ? But those could just be regular functions with an explicit signature. Putting an explicit type annotation on each expression seems a whole lot more convenient than mucking around with specialised classes or scope of instances. Before you answer, consider this very common pattern. It's so common there's a base library operator for it: type-level `==` https://downloads.haskell.org/~ghc/latest/docs/html/libraries/base-4.12.0.0…; but the technique dates back to 2004/the HList paper at least: > class TypeEq a a' (b :: Bool) | a a' -> b > instance TypeEq a a True > instance (b ~ False) => TypeEq a a' b Then an example usage > instance (TypeEq e e' b, TypeIf b This That) => instance Elem e (Cons e' tail) where ... Rubric: `Elem` is searching for type `e` in some type-level heterogeneous list; if found (i.e. `TypeEq` returns `True`), the `TypeIf` despatches to `This`, else to `That`. It's crucial for `TypeEq` that both instances are in scope in all places. Ah, but I see the `TypeEq` example does not contain any "unreachable" tyvars by your definition below. In which case your specification is silent as to how type improvement is to behave. (But you claim your approach is instead of FunDeps; then what is to happen with both instances being able to unify with the type of some expression?) Then do you want to change the spec? This was the experience with the github rounds: the spec kept changing; the examples we'd worked through in earlier rounds then didn't work with the new spec. Therefore the claims were impossible to verify with any certainty. > > (Definition: [Reachable and unreachable type variables in constraints] > Consider a constrainted type C∪D⇒τ. A variable a ∈ tv(C) is reachable > from V = tv(τ) if a ∈ V or if a ∈ tv(π) for some π ∈ C such that there > exists b ∈ tv(π) such that b is reachable from V; otherwise it is > unreachable. > For example, in (F a b, X a) ⇒ b, type variable 'a' is reachable from > { b }, because 'a' occurs in constraint F a b, and b is reachable. > Similarly, if C = (F a b, G b c, X c), then c is reachable from {a}.) > > AntC

1 0

[ANNOUNCE] GHC 8.4.4 released
by Ben Gamari 15 Oct '18

15 Oct '18

Hello everyone, The GHC team is pleased to announce the availability of GHC 8.4.4, a patch-level release in the 8.4 series. The source distribution, binary distributions, and documentation for this release are available at https://downloads.haskell.org/~ghc/8.4.4 This release fixes several bugs present in 8.4.3 These include, - A bug which could result in memory unsafety with certain uses of `touch#` has been resolved. (#14346) - A compiler panic triggered by some GADT record updates has been fixed (#15499) - The `text` library has been updated, fixing several serious bugs in the version shipped with GHC 8.4.3 (see `text` issues #227, #221, and #197. - A serious code generation bug in the LLVM code generation, potentially resulting in incorrect evaluation of floating point expressions, has been fixed (#14251) As always, the full release notes can be found in the users guide, https://downloads.haskell.org/~ghc/8.4.4/docs/html/users_guide/8.4.4-notes.… Thanks to everyone who has contributed to developing, documenting, and testing this release! As always, let us know if you encounter trouble. How to get it ~~~~~~~~~~~~~ The easy way is to go to the web page, which should be self-explanatory: https://www.haskell.org/ghc/ We supply binary builds in the native package format for many platforms, and the source distribution is available from the same place. Packages will appear as they are built - if the package for your system isn't available yet, please try again later. Background ~~~~~~~~~~ Haskell is a standard lazy functional programming language. GHC is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating efficient code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces. GHC is distributed under a BSD-style open source license. A wide variety of Haskell related resources (tutorials, libraries, specifications, documentation, compilers, interpreters, references, contact information, links to research groups) are available from the Haskell home page (see below). On-line GHC-related resources ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Relevant URLs on the World-Wide Web: GHC home page https://www.haskell.org/ghc/ GHC developers' home page https://ghc.haskell.org/trac/ghc/ Haskell home page https://www.haskell.org/ Supported Platforms ~~~~~~~~~~~~~~~~~~~ The list of platforms we support, and the people responsible for them, is here: https://ghc.haskell.org/trac/ghc/wiki/Contributors Ports to other platforms are possible with varying degrees of difficulty. The Building Guide describes how to go about porting to a new platform: https://ghc.haskell.org/trac/ghc/wiki/Building Developers ~~~~~~~~~~ We welcome new contributors. Instructions on accessing our source code repository, and getting started with hacking on GHC, are available from the GHC's developer's site run by Trac: https://ghc.haskell.org/trac/ghc/ Mailing lists ~~~~~~~~~~~~~ We run mailing lists for GHC users and bug reports; to subscribe, use the web interfaces at https://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users https://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets There are several other haskell and ghc-related mailing lists on www.haskell.org; for the full list, see https://mail.haskell.org/cgi-bin/mailman/listinfo Some GHC developers hang out on #haskell on IRC, too: https://www.haskell.org/haskellwiki/IRC_channel Please report bugs using our bug tracking system. Instructions on reporting bugs can be found here:

1 0