December 2018 - Haskell-Cafe

Re: [Haskell-cafe] handling NULL value in database query with Maybe (or other ...)
by Damien Mattei 19 Dec '18

19 Dec '18

thank tou for your C/HASKELL "rosetta stone" about the Monad it helps a lot understanding the thing... i always thougt Monads are powerful but they are not easy sot manipulates syntactically for a beginner in Haskell. yes in fact what i secretly expected was a way to discard NULL fields automagically and it seems really possible with Haskell. Le 19/12/2018 11:27, Mario Lang a écrit : > Damien Mattei <mattei(a)oca.eu> writes: > >> using Nothing and Just compared to other language, it's the same than >> if i had written in C something like : >> if (x == NULL) printf("NULL\n"); >> else printf("%s",*x); >> >> i expected more from Haskell... > > Haskell actually offers more. > > 1. The type of "Maybe a" prevents you from ignoring the fact that "a" might > be null. In C, you can accidentally write > > printf("%s",*x); > > and risking a segfault. The compiler will not care. IN Haskell, the > types dont even allow you to write something like that. You would be > forced to check for Just or Nothing in one of several ways. > > Now, "Maybe a" doesn't only limit your abilities, it also offers you the > functions from the Functor, Applicative and Monad typeclasses. > > 2. Functor allows you to apply a function to the "a", as long as there is > some "a" inside the "Maybe a". So, "fmap f x" is roughly equivalent to: > > typeOfA f(typeOfA); > typeOfA *x func(typeOfA *x) { > if (x) { > typeOfA *val = malloc(sizeof(typeOfA)); > *val = f(*x); > return val; > } > return NULL; > } > func(x); > > (note that pure Haskell doesn't have assignment, so the translation to C > is a little bit more verbose then it might be if you were using values > on the stack.) i tried this: let resFMAP = fmap (\(Only a) -> (putStrLn ("a =" ++ Text.unpack a))) bd_rows_WDS but compile complains now that i use a Maybe variable instead of a plain one,strange because this exactly what i expected from Maybe use it to automatically discard the Nothing values (avoiding to putStrln them): Prelude> :load UpdateSidonie [1 of 1] Compiling Main ( UpdateSidonie.hs, interpreted ) UpdateSidonie.hs:293:75: error: • Couldn't match type ‘Maybe Text’ with ‘Text’ Expected type: [Only Text] Actual type: [Only (Maybe Text)] • In the second argument of ‘fmap’, namely ‘bd_rows_WDS’ In the expression: fmap (\ (Only a) -> (putStrLn ("a =" ++ unpack a))) bd_rows_WDS In an equation for ‘resFMAP’: resFMAP = fmap (\ (Only a) -> (putStrLn ("a =" ++ unpack a))) bd_rows_WDS | 293 | let resFMAP = fmap (\(Only a) -> (putStrLn ("a =" ++ Text.unpack a))) bd_rows_WDS | ^^^^^^^^^^^ Failed, no modules loaded. bd_rows_WDS is defined like this with a Maybe: (bd_rows_WDS :: [Only (Maybe Text)]) <- query conn qry_head_WDS (Only (name::String)) anyway i know enought in haskell now to remove myself the Nothing (NULL) values of the list doing that (it worked): -- remove the records having N°BD NULL let fltWDS = Prelude.filter (\(Only a) -> case a of Nothing -> False Just a -> True) bd_rows_WDS > > So you do not need to write an explicit if in Haskell. The Functor > instance of Maybe "knows" how to deal will null cases. > In particular, if it encounters a Nothing, it returns a Nothing, > ignoring the provided function. > > 3. Applicative allows you to apply a function to the "a"s of several "Maybe a" > values, returning a Maybe wrapping the result of that function. > So "f <$> x <*> y" is equivalent to > > typeOfA f(TypeOfA); > typeOfA *func(typeOfA *x, typeOfA *y) { > if (x && y) { > typeOfA *val = malloc(sizeof(typeOfA)); > *val = f(*x, *y); > return val; > } > return NULL; > } > func(x, y); > > The amount of boilerplate eliminated grows. > > 3. Monad allows you to chain several null-checks without having to write > out the nesting. This time, f, g and h return a "Maybe a", not just an "a": > > do > a <- f x > b <- g a > h b > > or > > f x >>= \a -> g a >>= \b -> h b > > is equvalent to something like > > typeOfA *f(typeOfA); > typeOfA *g(typeOfA); > typeOfA *h(typeOfA); > typeOfA *func(typeOfA x) { > if (x) { > type *a = f(*x); > if (a) { > type *b = g(*a); > if (b) { > return f(*b); > } > } > } > return NULL; > } > > or, in Haskell: > > case f x of > Just a -> case g a of > Just b -> h b > Nothing -> Nothing > Nothing -> Nothing > > The Monad typeclass really pays off, as it saves you from doing the null > checks and dereferencing. The nested "if null then null" stuff goes all > away, and you can chain several functions together that return a > possible null value. > >> ok reading twice the article in link, i admit there should be some >> adavantage using Nothing instead of null, such as type, and genericity >> and not being spcecific to alloated memory as in C ... > > Exactly. As I see it, the Functor, Applicative and Monad typeclasses > of the Maybe type give you the tools > necessary to reduce the boilerplate that results from forcing you to > deal with each and every null case in your code. > -- Damien.Mattei(a)unice.fr, Damien.Mattei(a)oca.eu, UNS / OCA / CNRS

2 1

Timing out a pure evaluation of an expression I did not write myself
by Ryan Reich 19 Dec '18

19 Dec '18

I want to time out a pure computation. My experience, and that described in various previous questions here and elsewhere (the best of which is https://mail.haskell.org/pipermail/haskell-cafe/2011-February/088820.html) is that this doesn't always work: for instance, >>> timeout 1 $ evaluate $ let x = 0 : x in last x does not time out because, apparently, the fact that the expression evaluates in constant space (i.e. never allocates) means that it never yields to the timeout monitor thread that would kill it. The solution that is described in the other iterations is to embed checkpoints in the expression that do allocate, giving the RTS a chance to switch contexts. However, in my application, the expression is /arbitrary/ and I do not have the freedom to inject alterations into it. (Don't argue this point, please. The expression is arbitrary.) How can I time out a tight loop like the above? Clearly, it can be done, because I can, say, alt-tab over to another terminal and kill the process, which exploits the operating system's more aggressively pre-emptive scheduling. Is there a solution using bound threads, say 'forkOS' instead of 'forkIO' in the implementation of 'timeout'? Unix signals? Some FFI-based workaround? Etc. Keep in mind that notwithstanding that comment, I don't actually want to kill the whole process, but just the one evaluation. Thanks in advance, Ryan Reich

8 16

Diagnosing build problems when cross-compiling hslua
by Vanessa McHale 18 Dec '18

18 Dec '18

Hi all, I recently ran into some troubles cross-compiling hslua for Raspberry Pi, viz. |cabal new-build --with-ghc arm-linux-gnueabihf-ghc --with-ghc-pkg arm-linux-gnueabihf-ghc-pkg Build profile: -w ghc-8.6.3 -O1 In order, the following will be built (use -v for more details): - hslua-1.0.1 (lib) (configuration changed) Configuring library for hslua-1.0.1.. Preprocessing library for hslua-1.0.1.. Types.hsc: In function ‘_hsc2hs_test1’: Types.hsc:59:12: error: ‘LUA_INTEGER’ undeclared (first use in this function) Types.hsc:59:12: note: each undeclared identifier is reported only once for each function it appears in Types.hsc:59:24: error: expected ‘;’ before numeric constant compilation failed| Any hints as to what's failing? Is this something wrong with hslua, hsc2hs, or cabal? And how would I go about fixing it? Cheers, Vanessa McHale

1 0

How to unify these three types with identical structures into one definition?
by ducis 16 Dec '18

16 Dec '18

Hello, Say I have a certain type for parse trees: data Expr = Var String | Enclosed String Expr String | Prefix Expr Expr | Ternary Expr String Expr String Expr deriving (Show,Eq,Ord,Generic)--,Typeable) Then I want a new type where every occurence of "Expr" definition changed to "[Expr]": data ExprL = VarL String | EnclosedL String [Expr] String | PrefixL [Expr] [Expr] | TernaryL [Expr] String [Expr] String [Expr] deriving (Show,Eq,Ord,Generic) Sometimes, I also want to use a DList instead of list. data ExprD = VarD String | EnclosedD String (DList Expr) String | PrefixD (DList Expr) (DList Expr) | TernaryD (DList Expr) String (DList Expr) String (DList Expr) deriving (Show,Eq,Ord,Generic) They have exactly the same structure, is there a way to unify the three definitions into one? Furthurmore, is it possible to generalise the latter two for all Functors ? Thanks, ducis

5 5

fmap use
by Damien Mattei 14 Dec '18

14 Dec '18

hello again, another question with Haskell, again with my database but that is again related to Monads: i have this code in main: rows <- query_ conn "SELECT Nom,distance FROM AngularDistance WHERE distance > 0.000278" let lg = Prelude.length rows let tst = if lg > 1 then "some" else "one or zero" it compiles and i assume it works, and i have a new (for those that have follow my previous posts) function like this one: -- this function will return the list of N°BD from WDS for a given name -- note: there could be multiple result for a given name in WDS due to components getBD_WDS :: Connection -> String -> IO Float getBD_WDS conn name = trace "Entering getBD_WDS" noBDfp where qry_head = "select DNUM from WDS where DISC = ?" :: Query bd_rows :: IO [Only Text] bd_rows = query conn qry_head (Only (name::String)) lg = fmap Prelude.length bd_rows -- tst = if (fmap lg) > 1 then "some" else "one or zero" noBDtxt :: IO Text -- noBDtxt = trace "lg " (fmap (fromOnly . Prelude.head) bd_rows) noBDtxt = (fmap (fromOnly . Prelude.head) bd_rows) -- noBDstr :: String -- noBDstr = Text.unpack noBDtxt noBDstr :: IO String noBDstr = fmap Text.unpack noBDtxt -- noBDfp = read $ noBDstr :: Float noBDfp :: IO Float noBDfp = trace "Exiting getBD" (fmap read noBDstr) the problem is that first i noticed that in a function to make working the same code than in Main i had to had almost always fmap before the line, i admit ,even if i'm teacher in functional programming in Scheme at University, i begin in Haskell and i don't always understand what i'm using, i try to learn it by instinct even if sometimes i read pages about Functor and Monads i have no time to get in the Mathematics theoretical knowledge behind Haskell, i try to learn by getting some solutions in Haskell-cafe and it works, i know now a lot more about Haskell than 2 weeks ago,so.... if someon could explain me a few more about fmap or just give what i must place in my function instead of let lg = Prelude.length rows let tst = if lg > 1 then "some" else "one or zero" i replace this in the function by: lg = fmap Prelude.length bd_rows OK for compilation, but then tst = if lg > 1 then "some" else "one or zero" does not compile: *Main> :load UpdateSidonie [1 of 1] Compiling Main ( UpdateSidonie.hs, interpreted ) UpdateSidonie.hs:80:18: error: • No instance for (Ord (IO Int)) arising from a use of ‘>’ • In the expression: lg > 1 In the expression: if lg > 1 then "some" else "one or zero" In an equation for ‘tst’: tst = if lg > 1 then "some" else "one or zero" | 80 | tst = if lg > 1 then "some" else "one or zero" | ^^^^^^ UpdateSidonie.hs:80:23: error: • No instance for (Num (IO Int)) arising from the literal ‘1’ • In the second argument of ‘(>)’, namely ‘1’ In the expression: lg > 1 In the expression: if lg > 1 then "some" else "one or zero" | 80 | tst = if lg > 1 then "some" else "one or zero" | ^ Failed, no modules loaded. and even the "fmap miraculous function" as i call it no more works: tst = if (fmap lg) > 1 then "some" else "one or zero" Prelude> :load UpdateSidonie [1 of 1] Compiling Main ( UpdateSidonie.hs, interpreted ) UpdateSidonie.hs:80:24: error: • Couldn't match expected type ‘a0 -> b0’ with actual type ‘IO Int’ • In the first argument of ‘fmap’, namely ‘lg’ In the first argument of ‘(>)’, namely ‘(fmap lg)’ In the expression: (fmap lg) > 1 | 80 | tst = if (fmap lg) > 1 then "some" else "one or zero" | ^^ Failed, no modules loaded. a solution to this proble i think , will help me a lot, i sticked with problems in haskell i would have already solved in Scheme or Python, that's really discouraging me of using Haskell, i'm obstinating myself because i really think it's a great language that push the programming to high levels of abstractions but for now it's a bit a nightmare, i must admit it... -- Damien.Mattei(a)unice.fr, Damien.Mattei(a)oca.eu, UNS / OCA / CNRS

3 7

MonadThrow, MonadReader and shake
by PICCA Frederic-Emmanuel 14 Dec '18

14 Dec '18

Hello , I would like your opinion, about this thread. http://mail.haskell.org/pipermail/beginners/2018-December/018403.html I do not know how to solve the issue. thanks Frederic

1 0

Announce: Haskell Platform 8.6.3
by Gershom B 13 Dec '18

13 Dec '18

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.6.3 Now available at https://www.haskell.org/platform/ This includes GHC 8.6.3, cabal-install 2.4.1.0, and stack 1.9.3. This is the first platform released in the 8.6 series, as we have waited until a number of bugfix ghc releases stabilized things across all core platforms (linux, os x, windows). A full list of contents is available at https://www.haskell.org/platform/contents.html The list of GHC changes is available at: https://ghc.haskell.org/trac/ghc/blog/ghc-8.6.1-released https://ghc.haskell.org/trac/ghc/blog/ghc-8.6.2-released https://ghc.haskell.org/trac/ghc/blog/ghc-8.6.3-released A list of cabal changes is available at: https://hackage.haskell.org/package/cabal-install-2.4.1.0/changelog A list of stack changes is available at: https://docs.haskellstack.org/en/stable/ChangeLog/#v193 There are a number of important changes in this release, with more changes planned in the future. First: Win32 builds are working again and provided. Thanks to all the folks (especially Tamar) who helped sort out the build issues on that platform. Second, only core builds are provided, not "full" builds. This release is the first one where cabal-install warns on legacy commands and asks users to either use the v1-prefix for them or the v2/new prefix to move to the new-build system. As such, providing additional global packages outside of the core set now makes even less sense than in the past, where we had been already discouraging it for some time. Finally, there are no linux generic builds provided, and instead we recommend use of the ghcup tool (https://github.com/haskell/ghcup/) in combination with the stack install script. We feel this gives a smoother and better experience than the existing install process, being less invasive (not requiring root) and more flexible (by running ghc's own configure script it can better detect differences in configuration between distros). What does this all mean for the future of the platform? What I would like to move towards is the following. First: replacing the mac installer by ghcup as well in the near future. While a native installer has its advantages, the same reasons that ghcup is recommended on linux hold for mac as well, although with somewhat less force. Because of how Windows works, the difficulties of moving from a native installer are much more real, and we would anticipate keeping a native installer for the time being. Second: with the platform installers (or recommended installers) now really a delivery mechanism for core binaries and nothing else, to move to split the platform into two components. A) a set of recommended install instructions for major platforms (and a native windows installer), and B) a set of recommended and known-compatible packages which cover most "extended standard-lib" bases and which we again grow much more freely, as in the past. This will require some redesign and reconceptualization of the website, and would be a great opportunity for people that want to chip-in to move things forward to get involved. Please reach out if you'd like to lend a hand! Happy Haskell Hacking all, Gershom

1 0

Call for Haskell.org Committee Nominations
by George Wilson 12 Dec '18

12 Dec '18

Dear Haskellers, It is time to put out a call for new nominations (typically but not necessarily self-nominations) to the haskell.org committee. We have one member of our committee due for retirement -- our chair Gershom Bazerman. To nominate yourself, please send an email to committee at haskell.org by the 7th of January, 2019. Retiring members are eligible to re-nominate themselves. Please feel free to include any information about yourself that you think will help us to make a decision. The Haskell.org committee serves as a board of directors for Haskell.org, a 501(c)3 nonprofit which oversees technical and financial resources related to Haskell community infrastructure. Being a member of the committee does not necessarily require a significant amount of time, but committee members should aim to be responsive during discussions when the committee is called upon to make a decision. Strong leadership, communication, and judgement are very important characteristics for committee members. The role is about setting policy, providing direction/guidance for Haskell.org infrastructure, planning for the long term, and being fiscally responsible with the Haskell.org funds (and donations). As overseers for policy regarding the open source side of Haskell, committee members must also be able to set aside personal or business related bias and make decisions with the good of the open source Haskell community in mind. We seek a broad representation from different segments of the Haskell world -- including but not limited to those focused on education, those focused on industrial applications, those with background in organizing users-groups, and those focused directly on our technical infrastructure. More details about the committee's roles and responsibilities are on https://wiki.haskell.org/Haskell.org_committee If you have any questions about the process, please feel free to e-mail us at committee at haskell.org, or contact one of us individually. Regards, George Wilson

1 0

ZuriHac 2019 takes place 14 to 16 June in Zurich, Switzerland
by Jasper Van der Jeugt 12 Dec '18

12 Dec '18

Hello Friends of Haskell, It is our great pleasure to announce that the next ZuriHac will take place from Friday the 14th to Sunday the 16th of June 2019. It will be hosted at the Hochschule Rapperswil on the shores of beautiful Lake Zurich. This will mark the 8th anniversary of ZuriHac since our beginnings in 2010. The Zurich Haskell Hackathon is a free, international, grassroots, and collaborative coding festival. Our goal is to connect Haskellers, expand the community, learn things from each other, and to work on Haskell libraries, tools, and infrastructure. This year, we will enjoy keynotes from: - Simon Peyton Jones - Susan Potter - Richard Eisenberg - Ryan Trinkle More keynote speakers will be announced. The event is open to any experience level, from beginners to gurus. We want to make a special effort to ensure that the event is welcoming and accessible to people completely new to Haskell. That is why we are super excited that, Julie Moronuki, co-author of Haskell Programming from first principles [1] and Joy of Haskell [2], has kindly agreed to teach a beginners course in one of the classrooms we have available. Additionally, there will be mentors that you can approach during the whole event with any Haskell-related questions. This is a great opportunity to meet your fellow Haskellers in real life, find new contributors for your project, improve existing libraries and tools or even start new ones! We will have space for over 400 attendees. Registration is free and will open on 26th of December, as a late holiday present to Haskellers around the globe. You can find this information and more on our website: https://zfoh.ch/zurihac2019 We would also like to thank our sponsors Digital Asset [3], DFINITY [4] and HSR [5] for their strong commitment to the Haskell community and for supporting this great event! Looking forward to seeing you there, The Zurich Friends of Haskell association [6] [1]: https://www.goodreads.com/book/show/25587599-haskell-programming [2]: https://joyofhaskell.com/ [3]: https://digitalasset.com/careers.html [4]: https://dfinity.org/jobs [5]: https://www.hsr.ch/ [6]: https://zfoh.ch/

1 0

Fwd: [Haskell-beginners] monad and variable result
by Damien Mattei 12 Dec '18

12 Dec '18

i'v got no solution from Haskell-beginners... perheaps is there some expert here? -------- Message transféré -------- Sujet : [Haskell-beginners] monad and variable result Date : Mon, 10 Dec 2018 11:32:23 +0100 De : Damien Mattei <mattei(a)oca.eu> Répondre à : The Haskell-Beginners Mailing List - Discussion of primarily beginner-level topics related to Haskell <beginners(a)haskell.org> Pour : The Haskell-Beginners Mailing List - Discussion of primarily beginner-level topics related to Haskell <beginners(a)haskell.org> have some code that works but want to put it in a simple function without sucess: getBD :: Connection -> String -> Float getBD conn name = noBDfp where qry_head = "select `N° BD` from sidonie.Coordonnées where Nom = ?" :: Query bd_rows = do local_bd_rows <- query conn qry_head (Only (name::String)) return local_bd_rows i want the variable local_bd_rows accessible in the 'where' clause how can i do that? note the goal is to do the same thing of my main function that works : main :: IO () --main :: Int main = do conn <- connect defaultConnectInfo { connectHost = "moita", connectUser = "mattei", connectPassword = "******", connectDatabase = "sidonie" } -- we get all the Double Stars that have angular distance superior to a threshold of 1 second = 0.000278 degree rows <- query_ conn "SELECT Nom,distance FROM AngularDistance WHERE distance > 0.000278" forM_ rows $ \(name,distance) -> putStrLn $ Text.unpack name ++ " " ++ show (distance :: Double) -- we will get the Durchmusterung Number BD from Sidonie and WDS and compare them for a given name -- Warning: there could be multiple result in WDS for a given entry name (due to components) -- first we get the N°BD from sidonie let name = "A 20" -- let qry = "select `N° BD` from Coordonnées where Nom = " ++ name let qry_head = "select `N° BD` from sidonie.Coordonnées where Nom = ?" :: Query -- bd_rows <- query_ conn "select `N° BD` from sidonie.Coordonnées where Nom = 'A 20'" bd_rows <- query conn qry_head (Only (name::String)) putStrLn $ show bd_rows putStrLn $ show name let resLst = Prelude.map fromOnly bd_rows let noBDtxt = fromOnly (Prelude.head bd_rows) :: Text -- let noBD2 = _ (Prelude.head bd_rows) putStrLn $ show resLst putStrLn $ show noBDtxt forM_ bd_rows $ \(Only a) -> putStrLn $ Text.unpack a let noBDstr = Text.unpack noBDtxt :: String let noBDfp = read $ noBDstr :: Float putStr "noBDfp =" (putStrLn (show noBDfp)) close conn print "Exit." for now i have errors in the function: Prelude> :load UpdateSidonie [1 of 1] Compiling Main ( UpdateSidonie.hs, interpreted ) UpdateSidonie.hs:47:28: error: • Ambiguous type variable ‘r0’ arising from a use of ‘query’ prevents the constraint ‘(QueryResults r0)’ from being solved. Relevant bindings include bd_rows :: IO [r0] (bound at UpdateSidonie.hs:46:9) Probable fix: use a type annotation to specify what ‘r0’ should be. These potential instances exist: instance Result a => QueryResults (Only a) -- Defined in ‘Database.MySQL.Simple.QueryResults’ instance (Result a, Result b) => QueryResults (a, b) -- Defined in ‘Database.MySQL.Simple.QueryResults’ instance (Result a, Result b, Result c) => QueryResults (a, b, c) -- Defined in ‘Database.MySQL.Simple.QueryResults’ ...plus 21 others (use -fprint-potential-instances to see them all) • In a stmt of a 'do' block: local_bd_rows <- query conn qry_head (Only (name :: String)) In the expression: do local_bd_rows <- query conn qry_head (Only (name :: String)) return local_bd_rows In an equation for ‘bd_rows’: bd_rows = do local_bd_rows <- query conn qry_head (Only (name :: String)) return local_bd_rows | 47 | local_bd_rows <- query conn qry_head (Only (name::String)) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Failed, no modules loaded. -- Damien.Mattei(a)unice.fr, Damien.Mattei(a)oca.eu, UNS / OCA / CNRS _______________________________________________ Beginners mailing list Beginners(a)haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

2 6