July 2016 - Haskell-Cafe

Join a transformer
by Michael Snoyman 11 Apr '18

11 Apr '18

I'm wondering if this pattern exists and has a name. We have the concept of joining a Monad: join :: Monad m => m (m a) -> ma How about joining a monad transformer? joinT :: (Monad m, MonadTrans t) => t (t m) a -> t m a I believe implementing this in terms of MonadTransControl[1] might be possible, but I was wondering if there's an already existing idiom for this. Michael [1] http://haddocks.fpcomplete.com/fp/7.4.2/20130301-40/monad-control/Control-M…

5 5

PatternSignatures (rant)
by Johannes Waldmann 06 Apr '18

06 Apr '18

Dear all, (this is a rant - please ignore) why has "PatternSignatures" been renamed to "ScopedTypeVariables" (in ghc-6.10)? show me the alleged "type variable" in this code: do x :: Int <- [ 1 .. 10 ] ; return $ x^2 and why on earth do I need to use a language extension at all to get to the most basic thing of declarative programming: to declare the type of an identifier? This seriously hurts (me, at least) when teaching Haskell. Thanks - J.W.

4 4

Source code location in IO?
by Tom Ellis 30 Jun '17

30 Jun '17

Is it compatible with the semantics of Haskell to have a function sourceLocation :: IO String which when run returns the source file location at which it is used? For example, suppose Main.hs is module Main where main = do putStrLn =<< sourceLocation putStrLn "Hello" putStrLn =<< sourceLocation It would print the following when run Main.hs:4 Hello Main.hs:6 and module Main where main = do let s = sourceLocation putStrLn =<< s putStrLn "Hello" putStrLn =<< s It would print the following when run Main.hs:4 Hello Main.hs:4 If this is not compatible with the semantics of Haskell, why not? I agree that the two programs must have the same denotation, but is there anything that requires them to have the same output when run? Tom

6 7

possible bug in latest hackage Elf (Elf-0.27)
by Baojun Wang 18 Feb '17

18 Feb '17

Hi list, with below test program: -- /* test1.c: build with -g -O0 */ include <stdio.h> static const char appmsg[] = "hello, world"; int main(int argc, char* argv[]) { fputs(appmsg, stdout); return 0; } --- elf-test1.hs module Main where import qualified Data.ByteString as B import qualified Data.ByteString.Char8 as C import Control.Monad import Data.Elf testelf = "/tmp/test1" testelfsym = C.pack "appmsg" lookupSymbol1 _ [] = Nothing lookupSymbol1 sym (t:ts) = case (snd (steName t)) of Nothing -> lookupSymbol1 sym ts Just sname -> if sname == sym then Just t else lookupSymbol1 sym ts lookupSymbol _ [] = Nothing lookupSymbol sym (t:ts) = case (lookupSymbol1 sym t) of Nothing -> lookupSymbol sym ts t1 -> t1 test1 elf symtab symbol = mapM_ (print) (elfSections elf) test2 elf symtab symbol = lookupSymbol symbol symtab test3 elf symtab symbol = lookupSymbol symbol symtab >>= \et -> findSymbolDefinition et mainloop elf symtab symbol = -- (test1 elf symtab symbol) >> print (test2 elf symtab symbol) >> print (test3 elf symtab symbol) >> return () main = do contents <- B.readFile testelf let elf = parseElf contents symtab = parseSymbolTables elf mainloop elf symtab testelfsym --- the latest Data.Elf doesn't geive correct output as expected: output will be: Just (EST {steName = (9,Just "appmsg"), steEnclosingSection = Just (ElfSection {elfSectionName = ".fini", elfSectionType = SHT_PROGBITS, elfSectionFlags = [SHF_EXECINSTR,SHF_ALLOC], elfSectionAddr = 4195908, elfSectionSize = 9, elfSectionLink = 0, elfSectionInfo = 0, elfSectionAddrAlign = 4, elfSectionEntSize = 0, elfSectionData = "H\131\236\bH\131\196\b\195"}), steType = STTObject, steBind = STBLocal, steOther = 0, steIndex = SHNIndex 14, steValue = 4195924, steSize = 13}) >From above, you can see the steEnclosingSection is wrong and offset by 1. The *correct* output should be: Just (EST {steName = (9,Just "appmsg"), steEnclosingSection = Just (ElfSection {elfSectionName = ".rodata", elfSectionType = SHT_PROGBITS, elfSectionFlags = [SHF_ALLOC], elfSectionAddr = 4195920, elfSectionSize = 17, elfSectionLink = 0, elfSectionInfo = 0, elfSectionAddrAlign = 4, elfSectionEntSize = 0, elfSectionData = "\SOH\NUL\STX\NULhello, world\NUL"}), steType = STTObject, steBind = STBLocal, steOther = 0, steIndex = SHNIndex 14, steValue = 4195924, steSize = 13}) Just "hello, world\NUL" After check Elf.hs, I found there could be two issues: 1) in sectionByIndex, (SHNIndex) should start from 0, not 1; this cause the steEnclosingSection from my exmaple offset by 1; 2) in findSymbolDefinition, start should substract the sectionAddr (base address). please see below diff for details: -- --- a/Elf.hs 2012-12-04 19:27:51.000000000 -0800 +++ b/Elf.hs 2014-05-14 22:57:01.014498515 -0700 @@ -1,5 +1,5 @@ -- | Data.Elf is a module for parsing a ByteString of an ELF file into an Elf record. -module Data.Elf ( parseElf +module Elf ( parseElf , parseSymbolTables , findSymbolDefinition , Elf(..) @@ -666,12 +666,12 @@ getSymbolTableEntries e s = -- If the size is zero, or the offset larger than the 'elfSectionData', -- then 'Nothing' is returned. findSymbolDefinition :: ElfSymbolTableEntry -> Maybe B.ByteString -findSymbolDefinition e = - let enclosingData = fmap elfSectionData (steEnclosingSection e) - start = fromIntegral (steValue e) +findSymbolDefinition e = steEnclosingSection e >>= \enclosingSection -> + let enclosingData = elfSectionData enclosingSection + start = ( (fromIntegral (steValue e)) - (fromIntegral (elfSectionAddr enclosingSection) ) ) len = fromIntegral (steSize e) - def = fmap (B.take len . B.drop start) enclosingData - in if def == Just B.empty then Nothing else def + def = (B.take len . B.drop start) enclosingData + in if def == B.empty then Nothing else Just def runGetMany :: Get a -> L.ByteString -> [a] runGetMany g bs @@ -712,7 +712,7 @@ getSymbolTableEntry e strtlb = return $ EST (nameIdx,name) sec typ bind other sTlbIdx symVal size sectionByIndex :: Elf -> ElfSectionIndex -> Maybe ElfSection -sectionByIndex e (SHNIndex i) = lookup i . zip [1..] $ (elfSections e) +sectionByIndex e (SHNIndex i) = lookup i . zip [0..] $ (elfSections e) sectionByIndex _ _ = Nothing infoToTypeAndBind :: Word8 -> (ElfSymbolType,ElfSymbolBinding) -- Would you please check above change and update Data.Elf hackage? I cannot find the author from http://hackage.haskell.org/package/elf-0.27 Thanks baojun

14 19

The 13-line example in Text.Megaparsec.Expr
by Jeffrey Brown 24 Sep '16

24 Sep '16

At the bottom of the Hackage documentation for Text.Megaparsec.Expr [1] is a 13-line demonstration program. It includes no import statements. I added the ones I could deduce, which produced this: import Text.Megaparsec import Text.Megaparsec.Expr import Text.Megaparsec.Lexer (symbol,integer) parens = between (symbol "(") (symbol ")") expr = makeExprParser term table <?> "expression" term = parens expr <|> integer <?> "term" table = [ [ prefix "-" negate , prefix "+" id ] , [ postfix "++" (+1) ] , [ binary "*" (*) , binary "/" div ] , [ binary "+" (+) , binary "-" (-) ] ] binary name f = InfixL (reservedOp name >> return f) prefix name f = Prefix (reservedOp name >> return f) postfix name f = Postfix (reservedOp name >> return f) That still won't compile, because GHC does not know what reservedOp means. Does reservedOp refer to something that no longer exists, or have I just not found it? [1] https://hackage.haskell.org/package/megaparsec-4.4.0/docs/Text-Megaparsec-E… -- Jeffrey Benjamin Brown

4 8

Data constructor ‘Minus’ comes from an un-promotable type ‘Ints’
by Nicholls, Mark 15 Sep '16

15 Sep '16

Hello, I clearly don’t really know what I’m doing…but at least I know it…. Here we defined the Naturals…and then attempt to construct the Integers…. > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE ExplicitForAll #-} > {-# LANGUAGE FlexibleContexts #-} > {-# LANGUAGE FlexibleInstances #-} > {-# LANGUAGE GADTs #-} > {-# LANGUAGE MultiParamTypeClasses #-} > {-# LANGUAGE PolyKinds #-} > {-# LANGUAGE StandaloneDeriving #-} > {-# LANGUAGE TypeFamilies #-} > {-# LANGUAGE TypeOperators #-} > {-# LANGUAGE UndecidableInstances #-} > {-# LANGUAGE ScopedTypeVariables #-} > import Prelude hiding (head, tail, (++), (+), replicate) > import qualified Prelude as P naturals > data Nat where > Z :: Nat > S :: Nat -> Nat I can now define + and * and prove things about them…1 * x == x etc….nice..but lets put that on one side. Borrow bits and bobs from singletons > data family Sing (a :: k) Borrow bits and bobs from singletons..i.e. the isomorphic values…my proofs in nat now map to SNat…double nice. > type SNat = (Sing :: Nat -> *) Create the integers by following my nose……(the integers are the equivalence class of pairs of naturals….) i.e. we have “positive” or “negative” or “zero”… > data Ints (a :: Nat) (b :: Nat) where > Minus :: SNat a -> Ints 'Z a > Zero :: Ints 'Z 'Z > Plus :: SNat a -> Ints a 'Z > Ok….this works as a set of values….but…. I can’t prove anything about these because the data constructors for my integers aren’t “promotable”…..so I cant do the same trick I did with Nat. “:k Zero” ….. Data constructor ‘Zero’ comes from an un-promotable type ‘Ints’ In a type in a GHCi command: Zero I’ve tried rejigging this in various futile and ignorant manners….but the bottom line is its…”un-promotable”…..look at the docs, and it says something vague about GADT’s…but that isnt the problem directly. Is there a nifty way around this log jam? (I can start proving things about ‘(Nat,Nat)….but this will soon become a bit clumsy….) Or do I just stop here and wrestle with getting agda installed and lose another few months in the agda-café (which appears to be a very nice place somewhere in finland….hmmmm…I think that’s something different). (I’ve already allegedly descended into cabal hell following my nose with an agda install… setup.exe: The program cpphs version >=1.18.6 && <1.19 is required but the version found at C:\Users\nichom\AppData\Roaming\cabal\bin\cpphs.exe is version 1.19). computer science would be good, if it wasn’t for the computers. CONFIDENTIALITY NOTICE This e-mail (and any attached files) is confidential and protected by copyright (and other intellectual property rights). If you are not the intended recipient please e-mail the sender and then delete the email and any attached files immediately. Any further use or dissemination is prohibited. While MTV Networks Europe has taken steps to ensure that this email and any attachments are virus free, it is your responsibility to ensure that this message and any attachments are virus free and do not affect your systems / data. Communicating by email is not 100% secure and carries risks such as delay, data corruption, non-delivery, wrongful interception and unauthorised amendment. If you communicate with us by e-mail, you acknowledge and assume these risks, and you agree to take appropriate measures to minimise these risks when e-mailing us. MTV Networks International, MTV Networks UK & Ireland, Greenhouse, Nickelodeon Viacom Consumer Products, VBSi, Viacom Brand Solutions International, Be Viacom, Viacom International Media Networks and VIMN and Comedy Central are all trading names of MTV Networks Europe. MTV Networks Europe is a partnership between MTV Networks Europe Inc. and Viacom Networks Europe Inc. Address for service in Great Britain is 17-29 Hawley Crescent, London, NW1 8TT.

5 11

Design Question - Functions taking 'subtype' like arguments but has to be restricted to one type
by Gurudev Devanla 06 Aug '16

06 Aug '16

Hello All, I have a design question where I could use some of your thoughts and suggestions. Here is the setup. I apologize for the long email but I have resisted asking this question, since it needs a long explanation, until now. I have a set of data structures defined as follows -- An Item that can be of two types, one whose value can be changed, one whose value are frozen once created data Item = FreeToChange {freeToChangeCount:: Int} | CannotChange {frozenCount:: Int} -- The item is part of a basket data Basket = Basket { name:: String, item::Item } -- The cart can have both kind of Baskets at the start of the program, or during runtime. data Cart = List Basket You can imagine this be a shopping cart with fixed set of items. Where the count of some of the items in the basket can be changed during shopping but not the count of the items once they are tagged as frozen. Therefore, valid operation are: 1. I can create an Basket with either FreeToChange item or CannotChange item. 2. I can update the count for FreeToChange item in the Basket 3. But, once I create an instance of the Basket to contain the CannotChange item, we cannot update the count anymore or update the Basket. One approach I have taken is to throw an error if this happens by pattern matching on type. But, this is an runtime check. addToBasket :: Basket -> Basket addToBasket b = let i = item b i' = case i of FreeToChange f -> FreeToChange {freeToChangeCount = f + 1} CannotChange f -> error ("This operation is not allowed") in b {item=i'} Here are my questions: 1. Is there a way to design the above data structures in such a way I could use the type system. 2. Since, these are runtime changes, is it even a good design pattern to push this responsibility to a type system? Thanks Guru

7 11

ANN: haskell-src-exts-simple
by Bertram Felgenhauer 02 Aug '16

02 Aug '16

Dear all, I've just released haskell-src-exts-simple 1.18.0.0 on hackage [1]. (This is the first release. The first two components of the version follow haskell-src-exts.) >From the README: This package provides a shim for haskell-src-exts, exposing the same AST but without annotations. This package is useful for synthesizing and manipulating HSE ASTs that don't carry source location information. It may also aid in porting packages from haskell-src-exts 1.17 to 1.18, but it is not a drop-in replacement for the old annotation-free AST. See [2] for details. Happy hacking, Bertram [1] https://hackage.haskell.org/package/haskell-src-exts-simple [2] https://github.com/int-e/haskell-src-exts-simple/blob/master/COMPATIBILITY.…

1 1

RFC: New version of haskell-src-exts without simplified AST
by Matthew Pickering 31 Jul '16

31 Jul '16

Dear all, For several months I have had a branch of haskell-src-exts which has been updated for all the new features in GHC 8. However, I have not yet released the changes as in this version I also removed the simplified AST. To those unfamiliar, HSE provides two ASTs, one which has source locations and one which doesn't. I have removed the one which doesn't. This simplifies maintenance and I think also makes the library easier to use. I have held back releasing this version as there are some people who use the simplified AST. The changes necessary for the new version are mechanical and easy to make. For example, David Fox updated haskell-names to use my branch [1] with few problems. The question is, are there any users of the library who object to this change? Matt [1]: https://github.com/haskell-suite/haskell-names/pull/73

3 7

Re: [Haskell-cafe] RFC: revisiting the simplified haskell-src-exts AST
by Matthew Pickering 31 Jul '16

31 Jul '16

Hello Bertram, This is a good idea. I also considered this but to provide a proper compatibility layer it is necessary to "bundle" pattern synonyms with suitable type constructors so that when users import the type constructor then they also import the suitable pattern synonyms. This feature was only implemented in GHC 8.0. It is currently not much effort to maintain HSE to support back to at least GHC 7.4 so it didn't seem worth sacrificing this. It would be good to provide this shim in future versions of the library but at the moment the feature isn't mature enough. Message me when you release this to Hackage and I will add a link to the README. Matt On Sat, Jul 30, 2016 at 11:22 PM, Bertram Felgenhauer via Haskell-Cafe < haskell-cafe(a)haskell.org> wrote: > Dear all, > > the latest major release of haskell-src-exts (version 1.18) removed > the annotation free variant of the Haskell AST. It occurred to me that > using ghc's pattern synonyms it is possible to offer a light-weight > simplified view on the annotated AST. For example, > Language.Haskell.Exts.Syntax defines > > data Name l = Ident l String | Symbol l String > > and we can provide a simplified view with all annotations equal to () > by doing > > {-# LANGUAGE PatternSynonyms #-} > import qualified Language.Haskell.Exts.Syntax as H > > type Name = H.Name () > pattern Ident a = H.Ident () a > pattern Symbol a = H.Symbol () a > > Because the type isn't changed, no code has to be reimplemented to > work with this AST. > > A first rough cut at an implementation can be found on github [1]. > Before releasing it on hackage (which requires some more polishing) > I'd appreciate feedback on the approach. Would you consider using > such a package? Is there a better approach? Also any thoughts on > usability (e.g., how to approach documentation) would be welcome. > > Cheers, Bertram > > [1] https://github.com/int-e/haskell-src-exts-simple > > > P.S. This grew out of an effort to update lambdabot to HSE-1.18, > which made me feel awful about all the superfluous and ugly () in > the resulting code. I also have some numbers showing that the > annotation-free view makes updating the code smoother: > > Using the annotation-free view, the update touches 75 lines: > src/Lambdabot/Plugin/Haskell/Eval.hs | 18 +- > src/Lambdabot/Plugin/Haskell/Pointful.hs | 201 +++++++++++++++---------------- > src/Lambdabot/Plugin/Haskell/Pretty.hs | 14 +- > src/Lambdabot/Plugin/Haskell/UnMtl.hs | 62 ++++----- > src/Lambdabot/Plugin/Haskell/Undo.hs | 115 ++++++++--------- > 5 files changed, 72 insertions(+), 75 deletions(-) > > Using the haskell-src-exts 1.18 AST, the update touches 208 lines: > src/Lambdabot/Plugin/Haskell/Pointful.hs | 87 ++++++++++++++----------------- > src/Lambdabot/Plugin/Haskell/Pretty.hs | 12 ++-- > src/Lambdabot/Plugin/Haskell/UnMtl.hs | 10 +-- > src/Lambdabot/Plugin/Haskell/Undo.hs | 34 ++++++------ > 5 files changed, 204 insertions(+), 206 deletions(-) > _______________________________________________ > 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