- Haskell-Cafe - Haskell.org

GHC 8.2.2 for WSL Ubuntu 16.04
by Yitzchak Gale 15 Feb '18

15 Feb '18

I have made available a build of GHC 8.2.2 with the config option: --disable-large-address-space You may find this useful if you are using Ubuntu 16.04 on Windows Subsystem for Linux. https://github.com/zoominsoftware/ghc-8.2.2-wsl Although Microsoft has been making gradual progress on the large address mapping issue[1][2], and the situation is much improved, there is still an extra startup latency of about 13 secs. for applications that pre-map a large address space as GHC does by default. This makes the standard GHC 8.2.2 binary unusable for compiling projects of any non-trivial size on WSL. You may find this GHC 8.2.2 binary more usable. Regards, Yitz [1] https://ghc.haskell.org/trac/ghc/ticket/13304 [2] https://github.com/Microsoft/WSL/issues/1671

4 5

Haskell future and UTF8 vs UTF-16
by Alan & Kim Zimmerman 14 Feb '18

14 Feb '18

Hi all What is the current and future status of UTF8 vs UTF-16 in the haskell world? I understand that currently Text uses UTF-16, and it is used generally because of compatibility requirements in the Microsoft ecosystem, but that there are movements afoot to move to a UTF8 only environment at some unspecified future point. The question arises as I ponder a pull request on haskell-lsp to switch to a UTF-16 based library[1] Alan [1] https://github.com/alanz/haskell-lsp/pull/70

8 7

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 174, Issue 13
by Mikhail Baykov 14 Feb '18

14 Feb '18

recursion-schemes package might do the trick. I wrote TH for it and somebody took care of getting it merged in. It should simplify some of this boilerplate. > > I am looking for a solution to get rid of this silly boilerplate: > > eval :: Ord var => Map var Bool -> Proposition var -> Bool > eval ctx prop = evalP $ fmap (ctx Map.!) prop > where > evalP = \case > Var b -> b > Not q -> not $ evalP q > And p q -> evalP p && evalP q > Or p q -> evalP p || evalP q > If p q -> evalP p ==> evalP q > Iff p q -> evalP p == evalP q > > What I would like to do in essence is to replace the data constructors like so: > > -- Not valid Haskell!! Can't pattern match on constructor only... > magic = \case > Var -> id > Not -> not > And -> (&&) > Or -> (||) > If -> (==>) > Iff -> (==) > > compile = transformAST magic $ fmap (\case 'P' -> False; 'Q' -> True) > >>>> compile (Iff (Not (And (Var 'P') (Var 'Q'))) (Or (Not (Var 'P')) (Not (Var 'Q')))) > ((==) (not ((&&) (id True) (id False))) ((||) (not (id True)) (not (id False)))) > > Note how the compiled expression exactly mirrors the AST, so there should be some meta programming technique for this. > > Does anyone have an idea how I can achieve this? > > The full source code is here: https://gist.github.com/vimuel/7dcb8a9f1d2b7b72f020d66ec4157d7b

2 1

How do you turn off GHC flags?
by Christopher Done 14 Feb '18

14 Feb '18

If I run :set -fdeferred-type-errors in GHCi, how do I turn it off again? I tried -f-deferred-type-errors and -fno-deferred-type-errors and neither are recognized. Cheers

2 3

Proposal for GHC: global HasFoo classes
by KAction＠gnu.org 13 Feb '18

13 Feb '18

Hello! I have idea for GHC to make working with lenses even more convenient. # Rationale Let us recall, that "type Lens' a b = (a -> f a) -> (b -> f b)" is about accessing some value of type `a' somewhere deep in value of type `b'. Let us consider that we have following datatypes: -- module 1 {-# LANGUAGE DisambiguateRecordFields #-} data Foo = Foo { _a :: Int, _b :: Double } data Bar = Bar { _a :: Double, _c :: Char } Since we want to be able to use 'a' as both lens into 'Foo' and into 'Bar', we would use 'makeFields' function from 'lens' package, and get something like this generated (implementation is omited): -- module 1 class HasA w p | w -> p where a :: Lens' w p class HasB w p | w -> p where b :: Lens' w p class HasC w p | w -> p where c :: Lens' w p instance HasA Foo Int instance HasA Bar Double instance HasB Foo Double instance HasC Bar Char It is all great and convenient, but what if we have another module with -- module 2 data Quiz = Quiz { _a :: Bool } In same spirit, 'makeFields' will create -- module 2 class HasA w p | w -> p where a :: Lens' w p instance HasA Quiz Bool Now, you import unqualified both modules, and you have two versions of 'a' function, one per module. From GHC's point of view, class HasA in module 1 and module 2 are different, while we, humans, understand, that they are not. To mitigate this problem, common convention is to collect all types, used in package, and their lenses in signle module. But there is no solution {as far as I know} for lenses from different packages. # Proposal Let us introduce a new extension -XGlobalLensClasses (better name is welcome). When this extension is activated in module, you can write instances like instance HasFoo Foo Int where foo = -- apporiate lens with following implicit class definition: class HasFoo w p | w -> p where foo :: Lens' w p After that, module can export 'foo'. All implicit HasFoo classes, whose instances are defined in different modules are considered the same. It eliminates problem, described in rationale if both modules in consideration used proposed extension. It should be noted, that this extension would not disrupt any existing code, although in distant future we could have it by default. # Alternative idea The proposal of making global only one particular class namespace 'Has<Foo>' with very specific signature is not generic enough. Maybe we can add option to mark class definition as global instead, merging all global classes with same signature together? Sounds more complicated, but this solution will not upset those people who disagree with Lens-based HasFoo classes. Opinions?

3 2

Midlands Graduate School 2018 - registration now open!
by Graham Hutton 13 Feb '18

13 Feb '18

Dear all, Midlands Graduate School (MGS) registration is now open! Eight courses on dependently typed programming, category theory, lambda calculus, denotational semantics, and more. 9-13 April 2018, Nottingham, UK. Spaces are limited, so early registration is recommended. Please share! http://tinyurl.com/MGS18NOTT Best wishes, Graham Hutton and Henrik Nilsson ========================================================== *** CALL FOR PARTICIPATION *** Midlands Graduate School 2018 9-13 April 2018, Nottingham, UK http://tinyurl.com/MGS18NOTT BACKGROUND: The Midlands Graduate School (MGS) in the Foundations of Computing Science provides an intensive course of lectures on the mathematical foundations of computing. The MGS has been running since 1999, and is aimed at PhD students in their first or second year of study, but the school is open to everyone, and has increasingly seen participation from industry. We welcome participants from all over the world! COURSES: Eight courses will be given. Participants usually take all the introductory courses and choose additional options from the advanced courses depending on their interests. Invited course - Type-Driven Development with Idris, Edwin Brady Introductory courses - Lambda Calculus, Venanzio Capretta - Category Theory, Roy Crole - Domain Theory and Denotational Semantics, Achim Jung Advanced courses - Univalent Foundations, Benedikt Ahrens - Coalgebra, Alexander Kurz - Separation Logic, Georg Struth - Machine Learning, Michel Valstar REGISTRATION: Registration is £550 for student, academic and independent participants, and £850 for industry participants. The fee includes 5 nights single en-suite accommodation (Sun-Thu), lunch and coffee breaks, and the conference dinner. The registration deadline is Friday 16th March. Spaces are limited, so please register early to secure your place. SPONSORSHIP: We offer a range of sponsorship opportunities for industry (bronze, silver and gold), each with specific benefits. Please see the website for further details. ========================================================== This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law.

1 0

Re: [Haskell-cafe] Replace data constructors via meta programming
by Olaf Klinke 13 Feb '18

13 Feb '18

Vilem, I suggest to use free monads. They reduce boilerplate a little. First, separate the variable form the rest of the syntax: data Prop v = Not v | And v v | Or v v | If v v | Iff v v -- maybe GHC can derive this instance for you, given the appropriate language extension flag. instance Functor Prop where fmap f (Not p) = Not (f p) fmap f (And p q) = And (f p) (f q) fmap f (Or p q) = Or (f p) (f q) fmap f (If p q) = If (f p) (f q) fmap f (Iff p q) = Iff (f p) (f q) Then use Control.Monad.Free from the package 'free'. It also has a template Haskell part. The function you want is called 'iter' there, and applying a context of type var -> Bool is simply fmap. Note that a Map from var to Bool does not always yield a total reduction, since your formula might contain variables that are not in the Map. data Free f var = Pure var | Free (f (Free f var)) instance Functor f => Monad (Free f) where return = Pure Pure a >>= f = f a Free m >>= f = Free (fmap ((=<<) f) m) type Proposition var = Free Prop var type Predicate = Free Prop Bool -- F-algebras for functor f class Functor f => FAlg f a where alg :: f a -> a instance FAlg Prop Bool where alg (Not b) = not b alg (And p q) = p && q alg (Or p q) = p || q alg (If p q) = not p || q alg (Iff p q) = p == q eval = iter alg :: Predicate -> Bool map_and_eval ctx = iter alg . fmap ctx If feasible, remove If and Iff from the Prop type and make them binary functions on type Proposition var instead. That reduces the boilerplate further. -- Olaf

1 0

GHC/GHCi
by Vladyslav Nikolayevich 10 Feb '18

10 Feb '18

Hi, GHCi https://hackage.haskell.org/package/ghc-8.2.1/docs/GHCi.html doc says that: `Interacting with the interpreter, whether it is running on an external process or in the current process.` but where I can get some examples haw to “connect” to the already running ghci, do some staff and reload ghci session them? -- С уважением, Владислав Ищенко

2 1

mistaken post
by Doug McIlroy 10 Feb '18

10 Feb '18

Apologies for my off-topic post about shell programming yesterday. (I replied to the wrong message in my inbox.) Doug

2 1

[JOBS] Formal methods positions at Intel
by Levent Erkok 10 Feb '18

10 Feb '18

We have two open positions in formal methods/verification at our team at Intel: http://jobs.intel.com/ShowJob/Id/1504155/Sr.-Formal-Verification-Engineer/ While the work centers around formal-verification of Intel's microprocessor offerings, people with background in functional programming and generally interested in correctness proofs of both software and hardware would be well suited. SAT/SMT solving, BDDs, Model-checking are most commonly occurring terms you hear on a daily basis. Feel free to contact me in private for questions, or send me your CV. Cheers, -Levent.

1 0