- Haskell-Cafe - Haskell.org

CfP: Dutch FP-day 2018
by Arjen 04 Oct '17

04 Oct '17

Dear all, The next Dutch Functional Programming day will take place on Friday 5th of January 2018, at the Walter Bos Complex of the Dutch Tax Service at the John F. Kennedylaan 8, Apeldoorn. This is the first call for presentations, and we apologize if you received multiple copies. If you would like to give a presentation, please send an e-mail to a.van.weelden(a)belastingdienst.nl with a title, abstract, name of the speaker and expected duration of the talk. We'll try our best to make a proper program out of it with various subjects related to functional programming. Please note that to the nature of the location, registration in advance is required. As well as matching identification (passport, driver's license, or similar) before entering the venue! Photography and/or setting up a local WiFi network is explicitly not allowed. A dinner (pizza's) and drinks will be provided free of charge at the end of the day at the same location. Given that registration is mandatory this time, we'll assume that you stay around for this unless you specify otherwise. More information about registering for attendance and a website with information about the schedule and location will follow soon(ish). Feel free to invite other people who might take an interest. Best regards and looking forward to seeing you, Betsy Pepels and Arjen van Weelden

1 0

Re: [Haskell-cafe] Loading a csv file with ~200 columns into Haskell Record
by dominic＠steinitz.org 03 Oct '17

03 Oct '17

I don’t know if this helps but here’s something I created in 5 minutes yesterday. Once you have the data you can convert to e.g. frames with all the help that types can give. I once used frames on a file with 10,000 columns and it worked (probably I shouldn’t have done this). Also an option is in Chris Done’s blog: https://www.fpcomplete.com/blog/2016/09/data-haskell PS My script below will fail if I have missing data but then I can use something better than read. > {-# OPTIONS_GHC -Wall #-} > > import qualified Data.Vector as V > import qualified Data.ByteString.Lazy as BL > import qualified Data.ByteString.Lazy.Char8 as BLC > import Data.Csv > import Data.List > import Plots > import Diagrams.Prelude > import Diagrams.Backend.Rasterific > > main :: IO () > main = do > evalsCsv <- BLC.readFile "/Users/dom/.local/share/simwork/data/Models/Lorenz.csv" > let records :: Either String (V.Vector (V.Vector BL.ByteString)) > records = decode NoHeader $ BLC.unlines $ BLC.lines evalsCsv > case records of > Left err -> putStrLn err > Right evals -> do > let hdrs :: V.Vector String > hdrs = V.map BLC.unpack $ V.head evals > let zss :: [[Double]] > zss = map (map read) $ map (map BLC.unpack) $ > transpose $ V.toList $ V.map V.toList $ V.drop 1 evals > renderRasterific "diagrams/lorenz.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!0) (zss!!1)) > renderRasterific "diagrams/lorenz1.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!0) (zss!!2)) > renderRasterific "diagrams/lorenz2.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!0) (zss!!3)) > renderRasterific "diagrams/lorenz3.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!1) (zss!!2)) > renderRasterific "diagrams/lorenz4.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!1) (zss!!3)) > renderRasterific "diagrams/lorenz5.png" (dims2D 500.0 500.0) > (renderAxis $ jSaxis (zss!!2) (zss!!3)) > > jSaxis :: [Double] -> [Double] -> Axis B V2 Double > jSaxis ts xs = r2Axis &~ do > linePlot' $ zip ts xs Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

EduHaskell
by erwig 03 Oct '17

03 Oct '17

Dear Haskell aficionados, We will be using Haskell in an introductory course to computer science for college freshmen. From my past experience in using Haskell for students, the biggest hurdle and source of frustration is the type checker, or more precisely, the error messages generated. I see three major kinds of errors that get in the way of a smoother programming experience: * Errors resulting from overloading * Errors due to undefined type class instances (specifically, Eq and Show) * Errors in the context of parametric polymorphism While these problems are not unsurmountable, having to talk about these errors is a distraction from the major goal of explaining basics of (functional) programming. It would be great to have a Haskell compiler that offers the following features (and maybe others): * Type classes and overloading could be turned off * Eq and Show (and maybe Ord) instances would be automatically defined for any data type definition (when type classes are enabled) My questions are: (1) Does there exist a good solution to this problem already? Should one use Helium? I haven't checked lately, but it used to avoid type classes. This might have the disadvantage of having to switch to GHC in case one wants to use overloading. (I have used Helium in the past, and while I admire the effort, I am not sure it's the best option.) Are there versions of the Prelude available that accomplish some of this? (2) Are there other Haskellers out there who also want a simpler, more educationally suited version of GHCi? (3) If the answer to (1) is NO and to (2) is YES, is there any interest in forming a group for creating something like "EduHaskell"? I'd be grateful for any comments or suggestions! Thanks, Martin

7 7

hs-bibutils 6.2 candidate package
by Václav Haisman 02 Oct '17

02 Oct '17

Hi. I have created a candidate package for hs-bibutils 6.2. This synchronizes the hs-bibutils with Bibutils which it wraps. The candidate is at https://hackage.haskell.org/package/hs-bibutils-6.2/candidate. Please check it out and test it if you are interested. -- VH

1 0

ANN: hledger 1.4
by Simon Michael 02 Oct '17

02 Oct '17

Aloha! I'm pleased to announce hledger 1.4. Thank you release contributors: Nicholas Niro, Hans-Peter Deifel, Jakub Zárybnický, Felix Yan, Mark Hansen, Christian G. Warden, Nissar Chababy and Peter Simons. Also, if I haven't already mentioned it: this year hledger turns 10! Here's the first commit, from January 27 2007: https://github.com/simonmichael/hledger/commit/85864b41 We have come a way, but there is much yet to look forward to. Onward and upward! The next major release is scheduled for 2017/12/31. What is hledger ? ----------------- hledger (http://hledger.org) is an evolving, dependable, robust, cross-platform program for tracking money, time, or any other commodity, using double-entry accounting and a simple plain text file format. It is a haskell reimplementation of Ledger and the plain text accounting concept, providing command-line, curses and web interfaces. hledger aims to be a pleasant and practical tool for personal, business or institutional finance and time tracking. What's new ? ------------ The full release notes are at http://hledger.org/release-notes#hledger-1.4 . Some highlights: - Easy install script: we have a new installation method for the hledger tools, intended to dodge common pitfalls and just-work more often. Building on the stack team's install script, this bash script is cross platform, uses cabal or stack, installs stack and GHC if needed, and installs the latest release of all major hledger packages. See http://hledger.org/download for details. - More batteries included: most experimental addon commands formerly shipped in bin/ are now built in and work out of the box. - New commands: balancesheetequity (a balance sheet including equity), tags (list tags in use), import (detects new transactions in multiple input files and adds them to the main journal, particularly useful with CSV downloads). - Balance reports can be sorted by amount - makes those high expenses easy to spot. - CLI conveniences: @ARGSFILE is expanded to the set of args/flags in ARGSFILE. depth:2 or --depth=2 can be written as -2. - Help improvements: reorganized docs page, a more useful commands list, a smarter help command, --help and -h are the same again (by popular demand), Getting started --------------- See http://hledger.org/download for all install methods. To get the latest hledger release, you may need to build it yourself using stack or cabal. But don't worry, this is.. getting quite painless. The new hledger installer requires only bash and will install everything you need in one step: the hledger tools in $HOME/.local/bin/, and (if required) stack and GHC in $HOME/.stack/. Run it like so: $ curl -sSLO http://hledger.org/hledger-install.sh $ less hledger-install.sh # review script, for the security conscious $ bash hledger-install.sh # install the latest hledger tools Ensure $HOME/.local/bin is in your $PATH. Now try some commands: $ hledger -h # quick help $ hledger help # list built-in manuals $ hledger add # record some transactions $ hledger # list available commands Now perhaps work through the tutorial at http://hledger.org/step-by-step.html Or review the fine documents, presentations etc. at http://hledger.org and http://plaintextaccounting.org Or say hello and ask questions in the #hledger IRC channel on Freenode: http://irc.hledger.org If you have been finding hledger useful, I invite you to become a sponsor or contributor to make it stronger. Donate using one of the funding links on the home page, give feedback, report bugs, send pull requests, write about it, or help in some other way. Thanks for your support! I hope to meet you online. -Simon

3 2

Mutable data structures and asynchronous exceptions
by Станислав Черничкин 30 Sep '17

30 Sep '17

It's quite hard to implement mutable data structures in presence of asynchronous exceptions. Since exception can arise at any point, it is not possible to guarantee atomicity of operation, hence mutable data structure may remain in incorrect state in case of interruption. One can certainly use maskAsyncExceptions# and friends to protect critical regions, but masking function are living in IO, mutable data structures on other hand trend to be state-polymorphic (to allow it usage in ST). This lead to conflicting requirements: - One should not care about asynchronous exceptions inside ST (it is not possible to catch exception in ST, hence not possible to use something in invalid state). More over, it is not even possible to do write “exception-safe” code, because masking functions not available. - One should provide accurate masking then using same data structures in IO. So I want do discuss several questions topics on this case. 1. Impact. Are async exceptions really common? Would not be easier to say: “ok, things can go bad if you combine async exceptions with mutable data structures, just don't do it”. 2. Documentation. Should library authors explicitly mention async exceptions safety? For example https://hackage.haskell.org/package/hashtables – is it async exceptions safe when used in IO? Or even worse https://hackage.haskell.org/package/ghc-prim-0.5.1.0/docs/GHC-Prim.html#v:r… - what will happened in case of async exception? This functions is sate-polimorphic, will it implicitly mask exceptions if used from IO? 3. Best practices. How should we deal with problem? Is creating separate versions of code for ST and IO is the only way? Probably it is possible to add “mask” to something like https://hackage.haskell.org/package/primitive-0.6.2.0/docs/Control-Monad-Pr… emit mask in IO instance and NOOP in ST version? Or maybe somebody know better patterns for async exeption safe code? -- Sincerely, Stanislav Chernichkin.

5 5

Reinventing the wheel? Does any existing package provide an applicatively lifted (>>) ?
by Viktor Dukhovni 29 Sep '17

29 Sep '17

When generating a report file from a database I found it much more efficient (significantly shorter runtime) to represent each row by an I/O action that prints the row, rather than to construct a Row object that to print and throw away. But the naive way to construct the I/O action can be tedious to maintain once the column count gets appreciably high: newtype Foo = Foo { _foo :: IO () } instance FromRow Foo where fromRow = Foo <$> (rowPrinter <$> field <*> field <*> field <*> ... <*> field) where rowPrinter :: Type1 -> Type2 -> Type3 -> ... -> TypeN -> IO () rowPrinter p1 p2 p3 ... pN = do printP1 printP2 printP3 ... printPN So I decided to applicatively decompose the rowPrinter function (with the actual name of "andthen" to be determined later) as: rowPrinter = (printP1 <$> field) `andthen` (printP2 <$> field) `andthen` (printP3 <$> field) `andthen` ... (printPN <$> field) which avoids the need to package the column printers explicitly into a single function, and may be somewhat more efficient a well. What was not immediately obvious to me was whether there's an "off the shelf" implementation of "andthen" I could just reuse. The necessary operator satisfies: andthen (f (m a)) (f (m b)) = f (ma >> mb) or, equivalently: a `andthen` b = (>>) <$> a <*> b for which http://pointree.io dutifully gives me: andthen = (<*>) . ((>>) <$>) Its type signature is: Prelude> :set prompt "l> " l> :m + Control.Applicative l> :m + Control.Monad l> :t ((<*>) . ((>>) <$>)) ((<*>) . ((>>) <$>)) :: (Monad m, Applicative f) => f (m a) -> f (m b) -> f (m b) l> It seems to me that this would have been done before, and the operator would already be present in some package, but I'm having trouble finding it. (Due to the hidden constructors of FromRow defining a Semigroup does not work out here, so I can't use (<>), which also inconveniently conflicts with Monoid (<>)). So my question is whether the operator in question is already available, under some name in some package, or else suggested names for it if new. -- Viktor.

5 6

[ANN] brittany-0.8.0.3
by lennart spitzner 29 Sep '17

29 Sep '17

- Support for ghc-8.2.1 - Fix quadratic performance bug full changelog at https://hackage.haskell.org/package/brittany-0.8.0.3/changelog -- lennart

1 0

[hs-bibutils] intention to take over package
by Václav Haisman 28 Sep '17

28 Sep '17

Hi. I would like to take over the hs-bibutils Hackage package. It has not been updated since 2014, the listed maintainer is not responsive to emails, and listed home page is 404 page. -- VH

1 1

Re: [Haskell-cafe] EduHaskell
by erwig 26 Sep '17

26 Sep '17

Thanks for all the useful hints and suggestions! Maybe I should have explained the constraints (and where they come from) in more detail. First, the course is NOT an introduction to programming, but an introduction to computer science more generally and thus also discusses several topics not typically addressed by a programming course. Second, computing concepts are introduced with the help of stories, and programming will only take place in the second half of the course (more details about the approach can be found at web.engr.oregonstate.edu/~erwig/SBT) Thus the goal of minimizing the need for explaining advanced type system features. Also, we have already created Haskell code, so that's why Elm, although a really nice language, is currently not an option because of its different syntax. Code.world is also a cool system, but we do currently require a REPL. I definitely will take another look a Helium. Again, thanks for all the responses so far! I'm still wondering which, if any, of the existing alternative preludes would potentially be a good substitute for educational purposes. -- Martin

2 1