July 2017 - Haskell-Cafe

"stack script" and extra-deps
by Patrick Pelletier 07 Jul '17

07 Jul '17

When I use "stack script", how can I specify a package which is not in Stackage? When using a stack.yaml, I can just specify such a package in extra-deps, but I'm not clear how to translate this to "stack script". Thanks, --Patrick

2 1

Prelude's documentation on Hackage incomplete?
by Benjamin Rickels 07 Jul '17

07 Jul '17

I was recently looking at the various functions the RealFrac <http://web.archive.org/web/20170702220651/https://hackage.haskell.org/packa…> type class provides and noticed, that Double <http://web.archive.org/web/20170702220651/https://hackage.haskell.org/packa…> isn't listed as an instance of it; and neither are Num, Real and Fractional mentioned as implemented instances in the documentation for Double. Now, somebody who is familiar with the hierarchy of the numeric type classes could of course rather easily deduct, that, since Double is an instance of RealFloat (this is mentioned in the documentation on Hackage), it is also required to implement all of the above. And (surely enough) the Haskell 98 Report <https://webcache.googleusercontent.com/search?q=cache:GKdvwWYGFLoJ:https://…> lists all the relevant implementations and so does a quick *:info Double* in GHCi. However I'd (assume and thus) argue, that most beginners who google (or especially hoogle) anything about Haskell, are often directed to the Hackage documentation itself - and any missing information there could lead to quite a bit of a headache; even more so, if this concerns something as important as the Prelude. Therefore I'd like to ask, whether this is a known issue and independently propose, that (in the meantime) an official recommendation somewhere to do a quick *:info <type class>* or :info *<type> *in GHCi yourself, as to find out, which type class instances are currently available, might help to alleviate some confusion. Benjamin

1 0

parallel Haskell
by Dennis Raddle 07 Jul '17

07 Jul '17

I have a program which does backtracking search in a recursive function. I followed the chapter in "Real World Haskell" to parallelize it. Without Control.Parallel, it uses about 25% of the CPU, namely one core out of four. With the suggestions in RWH it runs faster but still uses only 35% of the CPU max. So I set about creating a MWE in order to experiment and reach out for help. For some reason, my stripped down program isn't working with parallelism at all! There's no effect from the R.W.H. ideas. Can I get some suggestions as to why? Here's the program: -------------------------------------------- import qualified Data.List as L import Text.Printf import System.CPUTime import Data.Function import Control.Parallel -- Run backtracking search for a list of doubles, optimizing a -- fitness function on the list, called 'evalFunc'. At each step, use 'stepFunc' -- to generate a list of possible next Doubles that can be added to the list. -- We are done when the list has 'finalSize' elements. search1_par :: Int -> ([Double] -> Double) -> ([Double] -> [Double]) -> [Double] -> (Double,[Double]) search1_par finalSize evalFunc stepFunc listIn | length listIn == finalSize = (evalFunc listIn,listIn) | otherwise = let steps = stepFunc listIn (steps1,steps2) = divideListInTwo steps f s = search1_par finalSize evalFunc stepFunc $ s:listIn results1 = map f steps1 results2 = map f steps2 results = force results1 `par` (force results2 `pseq` (results1++results2)) in L.maximumBy (compare `on` fst) results force :: [a] -> () force xs = go xs `pseq` () where go (_:xs) = go xs go [] = 1 divideListInTwo :: [a] -> ([a],[a]) divideListInTwo [] = ([],[]) divideListInTwo xs = (take l xs,drop l xs) where l = length xs `div` 2 --------------------------------------------- -- some sample evaluation (fitness) functions and step generation functions. eval1 :: [Double] -> Double eval1 xs = v1 - v2 + v3 where v1 = sum $ zipWith (*) (cycle [1]) xs v2 = sum . map (*2) $ zipWith (*) (cycle [1,0]) xs v3 = sum . map (*3) $ zipWith (*) (cycle [1,0,0]) xs step1 :: [Double] -> [Double] step1 xs | l == 0 = take 8 $ xs | l == 1 = take 8 $ map (/2) xs | l == 2 = take 8 $ map (*3) xs where l = length xs `mod` 3 -------------------------------------------------------------------------------- -- main main = do t1 <- getCPUTime let f :: Double -> String f x = printf "%5.1f" x (_,result) = search1_par 13 eval1 step1 [1,2,3] putStrLn $ concatMap f result t2 <- getCPUTime putStrLn $ printf "CPU time: %.3f" ((fromIntegral $ t2-t1) / 1000000000000 :: Double)

3 6

Issue 61 :: Haskell Weekly
by Taylor Fausak 07 Jul '17

07 Jul '17

\ Haskell Weekly \/\/ Issue 62 <https://haskellweekly.news/issues/62.html> Welcome to another issue of Haskell Weekly! Haskell is a purely functional programming language that focuses on robustness, concision, and correctness. This is a weekly summary of what's going on in its community. ## Featured ## - YOW! Lambda Jam 2017 <https://www.youtube.com/playlist?list=PLIpl4GKFQR6dqCNb2J0eQFR21Lwnk4I86> Videos of 23 talks by Edward Kmett, John Hughes, Conal Elliott, Brian McKenna, Bodil Stokke, and others. - Perhaps not the answer you were expecting but you asked for it <https://personal.cis.strath.ac.uk/conor.mcbride/so-pigworker.pdf> A collection of Conor McBride's Stack Overflow answers. - Unit testing effectful Haskell with monad-mock <https://lexi-lambda.github.io/blog/2017/06/29/unit-testing-effectful-haskel…> > While monad-mock might not be anything drastically different from > existing testing techniques, my hope is that it can provide an > opinionated mechanism to make testing easy and accessible, even for > complex interactions with other services and systems. - Front Row is hiring a senior backend Haskell engineer (ad) <https://frontrow.workable.com/j/463B843754> > Come change how 6.5+ million K-12 US students learn Math, Language > Arts, Social Studies and more. Use data, advanced type systems, > great product design and deep pedagogy to change lives. - A major upgrade to Megaparsec: more speed, more power <https://markkarpov.com/post/megaparsec-more-speed-more-power.html> > The version 6 thus will aim to be not just a parser for human- > readable texts and source code, but "one size fits all" general > solution to parsing in Haskell, including low-level binary parsing. - Derive instances of representationally equal types <https://gist.github.com/Icelandjack/d258b88a0e0b3be2c0b3711fdd833045/fe806c…> > I made a way to get more free stuff and free stuff is good. - New version of FLTKHS with much better error messages and OpenGL integration <https://np.reddit.com/r/haskell/comments/6l85uj/announcement_new_version_of…> > Happy to announce a new major version of FLTKHS, the Haskell > binding to the FLTK for easy native cross-platform GUI apps in > Haskell. - Notes on fusion <http://teh.id.au/posts/2017/06/30/notes-on-fusion/index.html> > Fusion is one of those words that made me recoil for quite a few > years, since it sounds extremely complicated and arcane. A few > years into building applications in Haskell, I still hadn't forced > the thunk. - SuperRecord: Anonymous records for Haskell <https://www.athiemann.net/2017/07/02/superrecord.html> > A practical library for anonymous records that is both fast and has > an ergonomic interface for both using and extending it. - Typesafe modular arithmetic in Haskell <https://rkrishnan.org/posts/2017-06-20-typesafe-modulus-in-haskell.html> > We would like to get a type error (at compile time) if we do a > operation involving two numbers with a different modulus. The role > of a type system is to represent the invariants and so it will be > great to encode as many invariants of a particular value into the > type. - Lessons learned building a toy compiler <https://jaseemabid.github.io/2017/07/04/compiler.html> > We tend to think of compilers as big black boxes which transform > some high level language, let's say C into a binary in one big > step. I'd like to present it as a pipeline of languages and > transformations, each a bit simpler and slightly lower level than > the one before it. ## Package of the week ## This week's package of the week is Miso, a small isomorphic front-end framework. <https://hackage.haskell.org/package/miso-0.1.2.0> ## In brief ## - Diskhash: Disk-based, persistent hash tables <https://metarabbit.wordpress.com/2017/06/30/ann-diskhash-disk-based-persist…> - Graphing it out <https://mmhaskell.com/blog/2017/6/21/graphing-it-out> - highlight CLI application <https://functor.tokyo/blog/2017-07-01-highlight> - Idris dependent typing challenge: Bowling kata <https://deque.blog/2017/07/01/idris-bowling-kata/> - The Spiderman principle <https://www.snoyman.com/blog/2017/07/the-spiderman-principle> - What should a PostgreSQL migrator do? <https://medium.com/@jonathangfischoff/what-should-a-postgresql-migrator-do-…>

2 1

constraint inference
by Dmitry Olshansky 07 Jul '17

07 Jul '17

Hello, cafe! If we have many constraints then compiling is sometimes too slow. Especially if there are some type calculations. And I don't know how to divide this time among different source files because all constraints are checked only when we call a function. I tried to add constraint info into argument definition instead of the function signature but this trick is not working (see below). Is it (at least theoretically) possible to infer the constraint inside a function from the type of function's argument? ------------------------------------ $ stack ghci ---- GHCi, version 8.0.2: Prelude> import Data.Proxy Prelude Data.Proxy> import GHC.TypeLits Prelude Data.Proxy GHC.TypeLits> :set -XRankNTypes Prelude Data.Proxy GHC.TypeLits> let { f :: (KnownSymbol n => Proxy n) -> String; f = symbolVal } <interactive>:4:54: error: • No instance for (KnownSymbol n) arising from a use of ‘symbolVal’ Possible fix: add (KnownSymbol n) to the context of the type signature for: f :: (KnownSymbol n => Proxy n) -> String • In the expression: symbolVal In an equation for ‘f’: f = symbolVal ------------------------------------ Best regards, Dmitry

2 1

Re: [Haskell-cafe] representations of probability distributions
by David Banas 06 Jul '17

06 Jul '17

Hi Olaf, I can’t quite tell whether this is apropos to your request, but thought I’d mention it: https://wiki.haskell.org/Random_Processes <https://wiki.haskell.org/Random_Processes> -db

1 0

Re: [Haskell-cafe] representations of probability distributions
by Olaf Klinke 05 Jul '17

05 Jul '17

Thanks for the link, Benjamin. Can one give a Hasekll type to a particle filter? In the arxiv paper you linked, I found this quite unnerving sentence: "The divergence between the true conditioned distribution on execution traces and the distribution encoded by the program may depend strongly on what inference instructions are chosen and how they are interleaved with the incorporation of data." Does this mean: Here is a programming language that may or may not compute what you meant it to do? --Olaf

1 0

Instantiating a typeclass based on a runtime value?
by Saurabh Nanda 05 Jul '17

05 Jul '17

Overall context: I'm trying to port the DelayedJob library from Ruby/Rails world to Haskell. The basic idea is to serialise a job and write it to the DB, deserialise it, and run the job using a job-runner function, which is determined by the job-type. I'm using a type-class to define the custom job-runner, something on the lines of: class (FromJSON j, ToJSON j) => DelayedJob j where runJob :: j -> AppM () data SyncContactsJob = SyncContactsJob { userId :: UserId } deriving (Eq, Show, Generic, FromJSON, ToJSON) instance DelayedJob SyncContactsJob where runJob job = do -- entire job execution logic comes here Is there **any** type-system hackery, that will let me take a runtime value, eg. "SyncContactsJob", "DoBackupJob", and use that to run the correct version of the `runJob` function? That is, how do I write the following function: invokeJob :: JobId -> AppM () invokeJob jid = do jobRow <- fetchJob jid let jtype = jobRow ^. jobtype -- this will have "SyncContactsJob" jvalue = jobRow ^. jobdata -- this will have a Data.Aeson.Value runJob (......) -- QUESTION: What do I write here to make this compile?

3 2

local instances / scoped instances
by Anthony Clayden 05 Jul '17

05 Jul '17

Can anybody explain the idea of typeclass instances being declared with a scope? Im not sure if these two terms mean the same. Perhaps the difference is: * local instances are declared in the familiar let-style: `let <instance> in <expr>` So the scope is the body of the `in` expr. * scoped instances are declared as usual at the top level in a module. Scope is controlled by the export/import naming. (That is, theres a way to name/identify instances for export/import. Note that currently you cant control scope of instances; Theyre imported to any module that (transitively) imports the module where an instance is declared.) (I'm doubtful that controlling scope of the name-for-instance would actually have the desired effect. Compare if I declare: > data T = MkT Int > f :: T -> String and export `f`, but not `T` nor `MkT`; nevertheless the type of `f` in some distant module is still `T -> String` (or `M.T -> String`). So detail of the type itself is exported. What are the use cases for instances being anything other than top-level/global scope? One seems to be so that a method can use a value/function declared in a surrounding scope, without needing an explicit parameter passed around the whole program. This is explored in [Kis04] (and linked references, esp. Implicit configurations), particularly for passing run-time parameters into methods. (What imperative programmers might do via global variables. In Haskell: nowadays Implicit Parameters.) [Kis04] (and especially the link to The pioneering work of Kaes) laments that Kaes original description of typeclasses/instances has never been delivered. Im not convinced Kaes is actually describing local instances. Hes giving the formal semantics for instances using let-binding; because hes using let as the standard way in Lambda Calculus to introduce any binding. Usual let-binding in LC provides a fresh name for each binding. That is, if that same name is in an outer scope, the outer binding is shadowed/unreachable within the scope of the fresh name. But instance binding is different: * Theres no fresh name: the class name is exactly the one already in scope. * Theres no shadowing: this instance is _in addition to_ those already in scope. thats what overloading needs. Overloading a class method with two or more instances in the same scope means theres no principal type for the method [W&B88 Appendix A.7]. Thats why in Haskell classes/instances/methods are at top level only. The methods then do have a most-general principal type `show :: (Show a) => a -> String`. This early work was of course before MPTCs, FunDeps, Overlaps, Flexible Instances/Contexts, constrained existentials, constrained GADTs. AFAICT it was expected there would be only one instance per type. So making instances global probably wasnt too limiting. Ive seen some later ideas (especially scoped instances blocking the export of an instance) where the intent seems to be to have _different_ instances in different scopes for the same class/same type. For example (apparently) a pretty print format for `show`. Or an alternative `Ord` for case-insensitive sorting of Chars/Strings. What are the use cases here? In particular, whats wrong with either: * using a different class/method name for different behaviour (for example supplying a different comparison via `sortBy`); or * wrapping in a newtype and declaring an instance of `Show/Ord` on the different nominal type? Im worried: classes come with laws. For example wrt case-insensitive `Ord`: `Eq` is a superclass. So if we get case-insensitive `A <= a` and `a <= A`, the laws expect ` A == a `. Specifically the base library `Data.Set` relies on those laws for `Ord` to build balanced trees. (Theres also a whole load of puzzlement to do with how the instance scoping rules work, as explored in [Kis04]. But I dont want to worry about the implementation yet.) AntC [Kis04] Local instances: frequently still discussed and still not implemented, Kiselyov O. ??originally 2004, current version 2014 http://okmij.org/ftp/Haskell/TypeClass.html#local See also papers linked/referenced from that site. (Thank you Oleg for bringing out the issues.) [Kaes88] Parametric Overloading in Polymorphic Programming Languages, Kaes S. 1988 https://link.springer.com/content/pdf/10.1007%2F3-540-19027-9_9.pdf [W&B88] How to make ad-hoc Polymorphism less ad-hoc, Wadler P. & Blott S. 1988 https://people.csail.mit.edu/dnj/teaching/6898/papers/wadler88.pdf

1 0

on the number of ghc_worker threads on executables
by Ruben Astudillo 04 Jul '17

04 Jul '17

Dear list I noticed that on -threaded programs, even with just 1 capability (+RTS -N1) the number of worker tasks is usually more than 3. Examples of this are glirc and taffybar. What factors determine the number of Tasks/worker Tasks (OS threads) on a program? -- -- Ruben Astudillo -- PGP: 4EE9 28F7 932E F4AD

2 1