- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] programming style...and type classes...
by Olaf Klinke 06 Nov '16

06 Nov '16

While we have stated in this thread what typeclasses should _not_ be used for, we probably do not have carved out yet what `proper' use is. Please help me here. There are some typeclasses, e.g. Eq, Ord, Num, Monoid, Functor, Monad and Category, that arise from category theory and algebra, so these may be regarded as "good" typeclasses even though a type can have several sensible instances. In that case, newtypes may express this. (Data.Monoid is full of such newtypes.) In defense of Ord, there are in general many ways to totally order a set (read "set" as "total elements of a type"), and none of these ways can be preferred a priori. I would not say this is an inherently bad property of Ord. Similarly, there are many ways to put a monoid or ring structure on a set. Sometimes a type class can be avoided. For example, there is Data.Foldable.toList. Hence, instead of writing a Foldable instance for your type and use a function from the Data.Foldable module, you could instead write your own toList conversion function and then fold that list. (Does anyone know a function involving Foldable that can not be reduced to 'toList' followed by some list operations? Is [] the "free instance" of Fodable?) However, this reduction may be much more inefficient than using the Foldable instance directly. As a contrived example of what I mean by "free instance", consider the following class that abstracts traversal over a sequence of unknown length. class ListLike l where patternmatch :: l a -> Maybe (a,l a) You can write ListLike instances for [], Vector, Sequence and Set, but only [a] is the solution to the type equation x = Maybe (a,x). Then there are multi-parameter type classes. This has been described as metaphorical to a type-level Prolog language [1], since ultimately multi-parameter type classes (without methods) are relations between types. Another debatable use case: You define many record types, each of which has a sort key component: data A = A {foo :: Foo, bar :: Bar, keyA :: Int} data B = B {baz :: Baz, keyB :: Int} data C = C {... , keyC :: Int} It might be convenient to define a typeclass class HasSortKey a where key :: a -> Int and endow the types A, B and C with the obvious instances. But one could also avoid the class by making a parametric type: data Keyed a = Keyed {payload :: a, key :: Int} and then let data A = A {foo :: Foo, bar :: Bar} and so forth. Which version would you say is `proper' use? -- Olaf [1] https://www.reddit.com/r/haskell/comments/ck459/typed_typelevel_programming…

3 2

typeclass constraints?
by Gregory Guthrie 05 Nov '16

05 Nov '16

I want to define a bunch of tests in a simple demo program, where each test is locally defined, but all can be printed in one standard place. For example, each test result has a description::String, and a value, which can vary across tests. t1 = ("Sqrt(4)", sqrt(4.0)) ... t2 = ("sumList:", sum [1,2,3,4]) ... t3 = ("Description", value) ... So each test is of type: (String, value), for various value types all of which (only) have to be members of the Show class. Then for the summary of the tests, a loop: test (msg, val) = do print $ msg ++ " :: " ++ show val tests ts = mapM test ts ... Do tests [t1, t2, t3] This compiles, and assigns these types: test :: Show a => ([Char], a) -> IO () tests :: (Traversable t, Show a) => t ([Char], a) -> IO (t ()) Which works only as long as all tests have the same type for the second argument. I assume that it is somehow specializing the type to the actual encountered type of the arguments used, even though they are all show'able. So that they can vary on the actual types of the second argument, I tried something like this (pseudo code): type ATest = (Show a) => (String, a) since that wouldn't work, I tried: {-# LANGUAGE RankNTypes #-} type ATest = forall a. (Show a) => (String, a) Which compiles, but still fails on any variation in the value argument. Further, I want to abstract the type of tests from the loop which prints them, but I cannot then use it to convert from: test :: Show a => ([Char], a) -> IO () to test :: ATest -> IO () The basic idea was to define and use a polymorphic type for the tests in the definition of the testing loop. So perhaps a data structure instead; data (Show a) => ATest = Test (String, a) but that also fails, although it does give the right idea; all tests have a common structure, with a second value in the Show typeclass. I realize that generally one is recommended not to put constraints on the data type, but on the functions which use it - but here since I want a collection of tests it seems like I need a polymorphic list with consistent types. What is the right approach for this? Am I just getting the syntax wrong?

3 3

[ANN] github-0.15
by Oleg Grenrus 04 Nov '16

04 Nov '16

Hi, today I finally released a new version of `github` package [1], providing bindings to the most of GitHub API. [2] The most notable feature, it’s now compatible with GHC-8.0.1. As GitHub doesn’t provide (or I’m not aware of) machine readable specification of their API, the feature completeness and correctness depends on the users of the package. So, please try it out, find out what’s incorrect and missing, and ideally submit a PR. The plan for the next version is to merge in definitions from github-types [3], and then split types from `github` package back into `github-types`, so others can reuse the definitions without the rest of the packages, e.g. for servant-github [4] As you can see, we are still experimenting with “how to write bindings to rest APIs”, if you have some comments, please raise an issue. Cheers, Oleg Grenrus - [1]: http://hackage.haskell.org/package/github <http://hackage.haskell.org/package/github> - [2]: https://developer.github.com/v3/ <https://developer.github.com/v3/> - [3]: http://hackage.haskell.org/package/github-types <http://hackage.haskell.org/package/github-types> - [4]: http://hackage.haskell.org/package/servant-github <http://hackage.haskell.org/package/servant-github>

2 1

[ANN] Haskell ITA meetup in Bologna, Italy (2016-11-19)
by Francesco Ariis 04 Nov '16

04 Nov '16

Hello -cafe, the Italian Haskell Community (http://haskell-ita.it/) is happy to announce its autumn Haskell meetup! The event is going to be hosted in Bologna, on November 19th. The meeting will be in italian; we are going to form small groups/projects, to see Haskell in action and to share knowledge and opinions on functional programming. Everyone, experienced or not, is welcome, just make sure to have a laptop and a working Haskell environment! For a more detailed description of the event and to register, check: https://www.metooo.io/e/haskell-day-bologna (further information in italian follows) ----- - Dove: Bologna, Giardini Margherita, nella struttura "La Gabbia del Leone" (http://leserre.kilowatt.bo.it/gabbia-del-leone/) presso "Le Serre dei Giardini". - Quando: Sabato 19 Novembre, dalle 10:00 alle 18:00. - Chi: chiunque sia interessato alla programmazione funzionale, indipendentemente dal suo livello di esperienza. - Cosa faremo: lavoreremo in gruppi (2-6 persone circa) su diversi progetti. Ogni persona può scegliere il progetto che vuole, saranno date delle indicazioni sul livelo di conoscienza richiesto per contribuire. Lo scopo è provare a utilizzare Haskell per un progetto concreto, "toccare con mano" il modo che hanno altri di lavorare e di condividere le esperienze nelle numerose pause di gruppo. Lo scopo è puramente didattico, quindi nessuna ansia. - Cosa portare: un computer portatile e un ambiente Haskell configurato. - Come arrivare: dalla Stazione Centrale dei Treni di Bologna, prendere l'autobus 33 (frequenza 15 minuti) e scendere alla fermata "Giardini Margherita" e/o "Porta Santo Stefano" (circa 20 minuti di viaggio). Entrare nei Giardini Margherita, dall'ingresso di Via Castiglione 136 o Via Polischi 9, e recarsi presso "Le Serre dei Giardini", alla struttura "La Gabbia del Leone" (http://leserre.kilowatt.bo.it/gabbia-del-leone/) - Grazie a chi: all'associazione [Kilowatt](http://kilowatt.bo.it/about) che ha messo a disposizione gratuitamente la sala. - Per iscriversi: https://www.metooo.io/e/haskell-day-bologna

1 0

memory leak when using "forever"
by Zoran Bosnjak 04 Nov '16

04 Nov '16

Hello all, can you please explain why does this simple program leak memory. But, if I replace loop2 with loop1 (that is: without using "forever"), then it does not leak. Is this a problem in "forever" implementation or am I misusing this function? In the sources of base: http://hackage.haskell.org/package/base-4.9.0.0/docs/src/Control.Monad.html… ... there is some mention of memory leak prevention, but it looks like something is not right in this case. import Control.Concurrent import Control.Monad import Control.Monad.Trans import Control.Monad.Trans.Reader import Control.Monad.Trans.State main :: IO () main = do --let loop1 = (liftIO $ threadDelay 1) >> loop1 let loop2 = forever (liftIO $ threadDelay 1) _ <- runStateT (runReaderT loop2 'a') 'b' return () regards, Zoran

2 3

simple diagrams about GHC development flow
by Takenobu Tani 04 Nov '16

04 Nov '16

Hi cafe, For myself and new contributors, I drew overview diagrams about GHC development flow. GHC development flow http://takenobu-hs.github.io/downloads/ghc_development_flow.pdf https://github.com/takenobu-hs/ghc-development-flow Let's enjoy :) Regards, Takenobu

1 0

Re: [Haskell-cafe] programming style...and type classes...
by Olaf Klinke 03 Nov '16

03 Nov '16

Mark, Haskell typeclasses are a wonderful thing to have. I dare say that typeclasses are what makes haskell code modular and re-usable, because you can develop an algorithm "aginst the class interface" and users only need to supply a class instance for their own data type in order to use your algorithm. What the wiki warns about is misuse or over-use of typeclasses. Typeclasses express properties that different types have in common, and in that respect they are somewhat similar to OO-classes. However, there is no hierarchy of inheritance. It is true that typeclasses, particularly the more advanced ones with e.g. multiple parameters or functional dependencies, sometimes get into your way. One example is ambiguity arising from multi-parameter type classes: Suppose you have a two-parameter class {-# LANGUAGE MultiParamTypeClasses,FunctionalDependencies #-} class Foo a b where foo :: a -> b bar :: b -> (a,[Int]) Now you write a function using only bar: f :: (Foo a b) => b -> Int f = length.snd.bar The compiler will complain that it does not know which Foo instance to use, because while bar itself mentions both class parameters a and b, snd.bar has type b -> [Int] and hence lost the information about the first class parameter. Adding a functional dependency b -> a helps in this case. But the promise that for every b there is only one a such that Foo a b holds may not be what you want. So what went wrong? Observe that bar :: b -> (a,[Int]) is equivalent to two functions bar1 :: b -> a bar2 :: b -> [Int] and bar2 probably did not belong into the class Foo. We've been cramming to much into one typeclass and should therefore split Foo into two classes. Olaf

1 0

Package metadata format - notes from discussion
by Harendra Kumar 03 Nov '16

03 Nov '16

For reference, I have organized the major points of the discussion that happened earlier on haskell-cafe regarding package metadata format (cabal vs yaml, vs toml, vs hs). Take a look at this: https://github.com/harendra-kumar/package-metadata In my opinion, in the short term it might help if the cabal format is improved, the parser is modularized and detached from the cabal tool itself so that it can be used independently by any other tools wishing to do so. For long term possibility of change of format, I do not intend to pursue or investigate it further at this point of time but others who are interested are free to do so. -harendra

6 6

better error messages for YAML
by Tobias Dammers 03 Nov '16

03 Nov '16

Hello cafe, I have a bit of a conundrum here. The situation is such that I'm using the YAML package to parse YAML configuration files; some of the values in the file format require further parsing (using my own ginger library), and all that works fine. One problem though; since this is aimed at end users, I want to preset error messages that pinpoint the exact error location in case the ginger parse fails. However, the ginger parser doesn't get to see the entire YAML source, because it runs on just an individual string value inside the YAML, and the YAML parser itself doesn't report source positions either. The unfortunate result is that while I get "technically correct" parser errors from Ginger, the source positions they report are relative to the string value, i.e., all errors are reported as being on line 1 of an unnamed source file. The relevant code is here: https://github.com/tdammers/sprinkles/blob/master/src/Web/Sprinkles/Replace… The only solution I can think of right now involves writing my own YAML parser, and probably also an Aeson drop-in replacement; I don't really want to do that though. Is there any other way to get what I want? -- Tobias Dammers - tdammers(a)gmail.com

3 2

Creating string resources
by Zachary Kessin 03 Nov '16

03 Nov '16

I have an app with a UX in GHCJS and I want to have way for a non developer to edit the text, but then have it compiled into our code base. One obvious way would be just to have haskell modules that just has the strings in it as constants. But I thought to ask has anyone else come up with a solution to this? -- Zach Kessin SquareTarget <http://squaretarget.rocks?utm_source=email-sig> Twitter: @zkessin <https://twitter.com/zkessin> Skype: zachkessin ᐧ

3 2

Re: [Haskell-cafe] Suggestion for Data Structure regarding Timetabling and Time Intervals
by dominic＠steinitz.org 03 Nov '16

03 Nov '16

I don’t know if this is relevant but for manipulating time intervals, I have found the intervals package very useful. > Message: 5 > Date: Wed, 2 Nov 2016 21:26:32 +0100 > From: Olaf Klinke <olf(a)aatal-apotheke.de> > To: list(a)mroth.net > Cc: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] Suggestion for Data Structure regarding > Timetabling and Time Intervals > Message-ID: <63753058-716B-4D2B-8D8F-4B0F77732C2A(a)aatal-apotheke.de> > Content-Type: text/plain; charset=us-ascii > > Dear Michael, > > if you can be sure your intervals will never overlap, why not use a binary search tree, such as Data.Set from containers? You could make a data structure distinguishing major and minor intervals such as: > > type Time = -- your favourite totally ordered time type > data Major = Major { > fromTime :: Time, > untilTime :: Time} deriving (Eq) > data Minor = Minor { > after :: Time > before :: Time} deriving (Eq) > type TimeInterval = Either Minor Major > > instance Ord (Either Minor Major) where > Left a <= Left b = before a <= after b > Right a <= Right b = untilTime a <= fromTime b > Left a <= Right b = before a <= fromTime b > Right a <= Left b = untilTime a <= after b > > If I understood your intentions correctly, inserting a minor interval between a :: Major and b :: Major where a < b would mean to insert > > Minor {after = untilTime a, before = fromTime b} > > It might also be handy to define a new type (isomorphic to the product (a,b)) > > Anno a b = Anno a b > > whose Ord instance uses the Ord instance of b only, so that > > Anno "Some annotation" (Major t0 t1) > > is an interval bearing some annotation that can be ordered just like the Major type. > > If your intervals _do_ overlap, then two intervals can be in six different configurations (instead of LT, GT and EQ), and several tree structures exist that support some operations more or less efficiently. Bioinformatics and geometry has developed good data structures and algorithms to deal with efficient overlap searches. > > Olaf > > Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

Using unboxed integers
by Richard A. O'Keefe 03 Nov '16

03 Nov '16

I have x, y :: Int# I expect that x <=# y :: Bool but ghc 7.8 says Couldn't match expected type âBoolâ with actual type âInt#â In the expression: x <=# y In an equation for âbâ: b = x <=# y I have MagicHash and I've imported the right modules so that <=# is recognised as *something*, but at this point I'm baffled. I'm also not clear on how I can show an Int#.

3 3

Any students for master project in The Netherlands? (near Eindhoven)
by Damian Nadales 03 Nov '16

03 Nov '16

Hi, In my current team, we're looking for Master students to work in a project about checking RAML specifications automatically. We would like to develop this in the functional paradigm, but all the students we got so far have no FP exposure whatsoever. So if you know of somebody that might be looking for a master project and want to know more details please do let me know (maybe Alejandro and Jurriën have some ideas ;)). Best, Damian.

1 0

Call for participation: BayHac 2017 survey
by danburton.email＠gmail.com 02 Nov '16

02 Nov '16

I've invited you to fill out the following form: BayHac 2017 participation survey To fill it out, visit: https://docs.google.com/forms/d/e/1FAIpQLSdaHON7_RFSwR-2aAHpR8bJ6IUvpQ7Usul… BayHac is a Haskell hackathon weekend event for the San Francisco Bay Area and Silicon Valley. It will be a weekend of learning, hacking, and connecting with fellow Haskell enthusiasts. The proposed outline for 2017 is: Friday: Haskell in Production & getting started with Haskell Saturday: Get involved! Highlights of various open source Haskell projects. Sunday: Follow along: Abstract concepts taught via Haskell code snippets. As we solidify the location and date (tentatively March or April 2017), Haskellers of all varieties and skill levels are invited to participate to the degree that they are willing and able. If you are interested in attending BayHac 2017, kindly fill out this survey to help us calibrate and organize our preparations. Google Forms: Create and analyze surveys.

1 0

Re: [Haskell-cafe] Suggestion: A catalog of Language (broken links)
by Olaf Klinke 02 Nov '16

02 Nov '16

The documentation https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/Cabal-1.24.0.0… was mentioned in a post on haskell-cafe, and I found that every link to a specific KnownExtension there is broken. Olaf

2 1

Re: [Haskell-cafe] Suggestion for Data Structure regarding Timetabling and Time Intervals
by Olaf Klinke 02 Nov '16

02 Nov '16

Dear Michael, if you can be sure your intervals will never overlap, why not use a binary search tree, such as Data.Set from containers? You could make a data structure distinguishing major and minor intervals such as: type Time = -- your favourite totally ordered time type data Major = Major { fromTime :: Time, untilTime :: Time} deriving (Eq) data Minor = Minor { after :: Time before :: Time} deriving (Eq) type TimeInterval = Either Minor Major instance Ord (Either Minor Major) where Left a <= Left b = before a <= after b Right a <= Right b = untilTime a <= fromTime b Left a <= Right b = before a <= fromTime b Right a <= Left b = untilTime a <= after b If I understood your intentions correctly, inserting a minor interval between a :: Major and b :: Major where a < b would mean to insert Minor {after = untilTime a, before = fromTime b} It might also be handy to define a new type (isomorphic to the product (a,b)) Anno a b = Anno a b whose Ord instance uses the Ord instance of b only, so that Anno "Some annotation" (Major t0 t1) is an interval bearing some annotation that can be ordered just like the Major type. If your intervals _do_ overlap, then two intervals can be in six different configurations (instead of LT, GT and EQ), and several tree structures exist that support some operations more or less efficiently. Bioinformatics and geometry has developed good data structures and algorithms to deal with efficient overlap searches. Olaf

1 0

DefaultSignature versus overlapping instance
by Ole Krüger 02 Nov '16

02 Nov '16

Ahoy, I have the following type class. -- | An entity whose underlying information spans zero or more columns class ResultEntity a where -- | Build an instance of @a@. parseEntity :: RowParser a default parseEntity :: (EligibleDataType meta cons a) => RowParser a parseEntity = parseGeneric The EligibleDataType constraint allows me to construct a RowParser with the help of generics. It is so minimal that I am considering to transform the hole thing into this. -- | An entity whose underlying information spans zero or more columns class ResultEntity a where -- | Build an instance of @a@. parseEntity :: RowParser a instance {-# OVERLAPPABLE #-} (EligibleDataType meta cons a) => ResultEntity a where parseEntity = parseGeneric This makes defining new instances of ResultEntity obsolete for types that already satisfy the EligibleDataType constraint (basically everything that has a Generic instance). It is still possible to provide a hand-rolled instance. Undecidable and overlapping instances seem like a big no-no. Even after reading up on them, I can't get rid of the feeling that this might be dangerous. *Is it dangerous? *I am targeting GHC 8.0.1 with this. - Ole

1 1

file name to module name
by Corentin Dupont 02 Nov '16

02 Nov '16

Hi there, is there somewhere in the libraries a function to transform a file name into a module name? for exemple: "src/Data/List.hs" --> "Data.List" Thanks! Corentin

1 0

GHCJS Bad first impression
by Zachary Kessin 02 Nov '16

02 Nov '16

I am starting a project that might use ghcjs and it seems to me that if someone's first impression of it is tying stack install and having it take several hours to build everything that is not a very welcoming way to get people to use ghcjs. Why not precompiled binaries? Also while It has been compiling i have seen a lot of warnings? Zach -- Zach Kessin SquareTarget <http://squaretarget.rocks?utm_source=email-sig> Twitter: @zkessin <https://twitter.com/zkessin> Skype: zachkessin ᐧ

5 7

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 158, Issue 29
by Rik Howard 02 Nov '16

02 Nov '16

Richard thanks for your response and the references which I'll look into, the Dijkstra sounds particularly relevant. "Procedural-functional" is not novel; and as you also mentioned, Haskell, Clean and Mercury would qualify, if you chose to look at it that way, as would other languages. Any novelty in the note would only ever be in the way that the mix is provided. You raise salient points about the sort of challenges that languages will need to confront although a search has left me still unsure about PGPUs. Can I ask you to say a bit more about programming styles: what Java can't do, what others can do, how that scales? Regards Rik On 27 October 2016 at 13:00, <haskell-cafe-request(a)haskell.org> wrote: > Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > or, via email, send a message with subject or body 'help' to > haskell-cafe-request(a)haskell.org > > You can reach the person managing the list at > haskell-cafe-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Haskell-Cafe digest..." > > > Today's Topics: > > 1. Re: A Procedural-Functional Language (WIP) (Rik Howard) > 2. Re: A Procedural-Functional Language (WIP) (Rik Howard) > 3. Re: A Procedural-Functional Language (WIP) (Richard A. O'Keefe) > 4. Proof of concept of explanations for instance resolution > (Michael Sloan) > 5. Re: A Procedural-Functional Language (WIP) (Joachim Durchholz) > 6. Re: Proof of concept of explanations for instance resolution > (Tom Ellis) > 7. Fwd: How to best display type variables with the same name > (Christopher Done) > 8. CoALP-Ty'16: Call for Participation (František Farka) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Wed, 26 Oct 2016 16:48:47 +0100 > From: Rik Howard <rik(a)dcs.bbk.ac.uk> > To: Joachim Durchholz <jo(a)durchholz.org> > Cc: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] A Procedural-Functional Language (WIP) > Message-ID: > <CAAGBjQW+xzaU5kGQsm5S_et6v4YXOZ1QvkNN_cRfigRUOdbNMQ@ > mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Jo > > > > Question is not whether these things are precluded, question is how you > > want to tackle them. It's not even stating design goals here. > > > The section on Types has been amended to note that these questions form a > part of the ongoing work. > > > > > > > The salient point of this and some other features is that they make it > > easier to reason about a given program's properties, at the expense of > > making programming harder. > > > > You put that point well. > > > > > > The basic concept of subtypes is simple, but establishing a definition of > > "subtype" that is both useful and sound is far from trivial. > > > > I hope that there is nothing that I've said that could be interpreted as me > thinking otherwise. As you mentioned elsewhere, though, they look too > appealing to ignore. > > > > > > For example. mutable circles and mutable ellipses are not in a subtype > > relationship to each other if there is an updating "scale" operation with > > an x and y scaling factor (you cannot guarantee that a scaled circle > stays > > circular). > > The design space for dealing with this is far from fully explored. > > > > I'm not sure that the language could support mutable structures but I take > your point that there are complications. > > > > > > Also, subtypes and binary operators do not really mix; google for > > "parallel type hierarchy". (The core of the problem is that if you make > > Byte a subtype of Word, declaring the (+) operator in Word as Word -> > Word > > will preclude Byte from being a subtype because you want a covariant > > signature in Byte but that violates subtyping rules for functions. So you > > need parametric polymorphism, but now you cannot use the simple methods > for > > subtyping anymore.) > > > Clearly there is more to be done in this area. > > > > > > The key point to mention is that you want to maintain referential > > integrity. > > > > The document now mentions this. > > > > > > Sounds pretty much like the conseqences of having the IO monad in > Haskell. > > > > That seems fair to me although the broader impact on an entire program > would be different I think. > > > > > > I think you should elaborate similarities and differences with how > Haskell > > does IO, that's a well-known standard it is going to make the paper > easier > > to read. Same goes for Clean&Mercury. > > > Something like that is addressed in Related Work. Clean is already on the > list but it sounds, from your comments and those of others, as if Mercury > may be worth including as well. > > > > > > It's hard to tell whether it is actually new, too many details are > missing. > > > Certainly you have spotted the vagueness in the types however I think that > that issue can be momentarily set aside from the point of view of novelty. > The language is purely functional with respect to functions and provides > out-vars as the only mechanism for dealing with IO. Let's assume for the > moment that that all hangs together: if there is another language that does > that, no novelty; otherwise, there is novelty. > > Once again, your feedback has been useful and stimulating. Many thanks! > > Regards > Rik >

3 10

Cfa TTT 2017 (Type Theory Based Tools)
by Andreas Abel 01 Nov '16

01 Nov '16

CALL FOR ABSTRACTS TTT : Type Theory Based Tools ============================= Satellite workshop of POPL 2017, Paris France, January 15th [We have funding possibilities for students and young researchers, see below. Note the early deadline!] Overview ======== The aim of this workshop is to showcase modern tools based on type theory, whether designed for programming or for verification, whether academic projects or used in an industrial setting. It will provide a forum to highlight and discuss their common and their distinctive features, and the future directions of development of the tools. The program will consist of invited and contributed talks, and will encourage informal discussion. Abstracts will be displayed on the website of the workshop but there will be no proceedings. We solicit abstract submissions proposing demos, case studies, describing the impact of a theoretical result on practice, or any other aspect of the development and use of tools based on type theory. In particular, we welcome submissions about prototype implementations and promising work in progress, as soon as they have the potential of raising interesting discussions. This workshop is funded by the EUTypes COST project (https://eutypes.cs.ru.nl/) The program will include a plenary discussion on the role of the EUTypes project in the community and planning of activities for 2017. Invited Speakers ================ Robbert Krebbers, Delft University of Technology, Netherlands Aaron Tomb, Galois, US More speakers to be confirmed Registration ============ Registration information will be soon available at the main POPL 2017 website: http://conf.researchr.org/home/POPL-2017 Participant funding =================== The EUTypes COST project (https://eutypes.cs.ru.nl/) can fund students and young researchers from countries participating in the project to attend the workshop – check http://www.cost.eu/COST_Actions/ca/CA15123?parties to see if your country is listed. The application should include the following information: * Your name * Your institution * The name of your supervisor(s) * The url of your webpage if you have one * Your research topics or interests in 1 paragraph and should be sent to ttt2017(a)easychair.org as soon as possible and no later than November 20th. Contact ======= For any query about this workshop, please contact us at ttt2017(a)easychair.org Call for abstracts ================== Submissions for talks and demonstrations should be described in an extended abstract, between 1 and 2 pages in length. We suggest formatting the text using the two-column SIGPLAN LaTeX style (9pt font). Submission page: https://easychair.org/conferences/?conf=ttt2017 Important dates =============== Submission deadline: 30 November 2016 Notification: 15 December 2016 Workshop: 15 January 2017 Program Committee ================= Andreas Abel, Gothenburg University, Sweden Andrej Bauer, University of Ljubljana, Slovenia Assia Mahboubi, Inria Université Paris-Saclay, France Keiko Nakata, Germany -- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel(a)gu.se http://www2.tcs.ifi.lmu.de/~abel/

1 0

Suggestion for Data Structure regarding Timetabling and Time Intervals
by Michael Roth 01 Nov '16

01 Nov '16

I would like to experiment with timetabling algorithms and resource scheduling in a special use case: I have time intervals like A, B and C and they are put sequentially on a time line. However, between the major time intervals like A, B etc. their are always "minor" time intervals which separates the major ones. For example: a, A, ab, B, bc, C, c Upper case letters denotes "major" time intervals and lower case letters denotes the minor intervals which always separates the major ones. The minor time intervals only have a duration, their exact occurrence in time doesn't matter, only the fact that they occur between the major time intervals are important. The major time intervals start and stop a specific time; they don't overlap and maybe there is free time between major and/or minor time intervals. The minor time intervals "a" and "b" at the beginning and ending of the complete time line I'm not interested in and can be omitted completely. Say, to insert a time interval X after B, assuming there is enough free time between B and C, the resulting structure is: a, A, ab, B, bx, X, xc, C, c The minor time interval "bc" is discarded and two new minor time intervals "bx" and "xc" are inserted. I'm a little bit stuck what a good data structure would be for this problem. Additionally I would like to use an infinite data structure, because a priori I don't know how many time intervals have to be created and inserted into the time line. The time intervals are not generated in an ascending order. An algorithm will search for possible places to insert the new created major time intervals and creates the corresponding minor time intervals. There is the concept of a "present time" in this process. The algorithm can only manipulate the future. I thought to push all time intervals in the past respective to this "present time" to a MonadWriter to get my infinite list of time intervals. The "present time" is moved forward at specific events. What do you experts think about the approach with the MonadWriter? What would be a good data structure to ensure that all major time intervals are separated by minor time intervals? Thank you in advance for your ideas and comments, Michael Roth

1 0

Suggestion: A catalog of Language extensions
by Zachary Kessin 01 Nov '16

01 Nov '16

I have noticed that almost every haskell source file I have looked at has 4-8 language extensions. It would be very nice if there was a page somewhere that listed them all and gave a short (1 paragraph) description of what that extension does and what it is normally used for. That is not a detailed description of the API but a short description of *WHY* you might want to use it. Followed by a link to the API -- Zach Kessin SquareTarget <http://squaretarget.rocks?utm_source=email-sig> Twitter: @zkessin <https://twitter.com/zkessin> Skype: zachkessin ᐧ

4 3

Call for Workshop Proposals: ICFP 2017
by Lindsey Kuper 01 Nov '16

01 Nov '16

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2017 22nd ACM SIGPLAN International Conference on Functional Programming September 3-9, 2017 Oxford, United Kingdom http://conf.researchr.org/home/icfp-2017 The 22nd ACM SIGPLAN International Conference on Functional Programming will be held in Oxford, United Kingdom on September 3-9, 2017. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as tutorials) to be affiliated with ICFP 2017 and sponsored by SIGPLAN. These events should be less formal and more focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on September 3 (the day before ICFP) and September 7-9 (the three days after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: November 19, 2016 Notification of acceptance: December 18, 2016 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2017 workshop co-chairs (David Christiansen and Andres Loeh), via email to icfp2017-workshops(a)googlegroups.com by November 19, 2016. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by December 18, 2016, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2017-files/icfp17-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://www.sigplan.org/Resources/Proposals/Sponsored/ ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2017 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: David Christiansen (Indiana University) Workshop Co-Chair: Andres Loeh (Well-Typed LLP) General Chair: Jeremy Gibbons (University of Oxford) Program Chair: Mark Jones (Portland State University) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (David Christiansen and Andres Loeh), via email to icfp2017-workshops(a)googlegroups.com

1 0

PSA: gcc-6.2.0 breaks linking in ghc 7.10.3/8.0.1
by Alan & Kim Zimmerman 31 Oct '16

31 Oct '16

On my Debian testing machine, after gcc updated to gcc (Debian 6.2.0-9) 6.2.0 20161019 I started getting linker errors complaining about -fPIC Herbert Valerio Riedel pointed out on #hackage that the settings file has to be updated to cope with this. So, the files /opt/ghc/7.10.3/lib/ghc-7.10.3/settings /opt/ghc/8.0.1/lib/ghc-8.0.1/settings need to be updated to have the following values set ("C compiler flags", "-fno-PIE -fno-stack-protector"), ("C compiler link flags", "-no-pie"), ("ld flags", "-no-pie"), The precise location of these files may differ on your machine. Alan

2 1

GHCJS Best practices
by Zachary Kessin 31 Oct '16

31 Oct '16

We are thinking about building our frontend with GHCJS and I am trying to figure out what is the best way to do is? Problem is that when I googled variations of "How to architect a GHCJS app " etc I really din't get anything so a few questions 1) Is anyone building mid-large sized apps in GHCJS 2) How do you architect them 3) what libraries are there Zach -- Zach Kessin SquareTarget <http://squaretarget.rocks?utm_source=email-sig> Twitter: @zkessin <https://twitter.com/zkessin> Skype: zachkessin ᐧ

2 1

[ANN] hledger 1.0
by Simon Michael 30 Oct '16

30 Oct '16

Attention, attention hledger-folk! Once again, Happy Hallowe'en. After almost ten years of steady development, and one year since our last major release, I am very pleased to announce.. _ _ _ _ ___ _ | |__ | | ___ __| | __ _ ___ _ __ / | / _ \ | | | '_ \| |/ _ \/ _` |/ _` |/ _ \ '__| | || | | | | | | | | | | __/ (_| | (_| | __/ | | || |_| | |_| |_| |_|_|\___|\__,_|\__, |\___|_| |_(_)___/ (_) |___/ hledger's 1.0 release! It's about time! hledger (http://hledger.org) is a cross-platform program for tracking money, time, or any other commodity using double-entry accounting and a simple plain text file format. Inspired by Ledger CLI, hledger provides command-line, curses and web interfaces, and aims to be a reliable, practical tool for daily use. Notable changes since 0.27: - the hledger.org website is simpler, clearer, and more mobile-friendly - docs have been reorganized, with more focussed manuals available in multiple versions, formats and as built-in help - we support the latest GHC (8 and 7.10), stackage snapshots, and libs. (GHC 7.8 and 7.6 support are not currently supported, maintainers welcome.) - hledger has migrated from parsec to megaparsec and from String to Text, parsers have been simplified, memory usage is ~30% less on large files, speed is slightly improved all around - --pivot (group by arbitrary tag instead of account) and --anon (obfuscate account names) are now supported - hledger-ui has acquired many new features making it more useful (file editing, filtering, historical/period modes, quick period browsing..) - hledger-web is more robust and more mobile-friendly - hledger-api, a simple web API server, has been added - a new "timedot" file format allows retroactive/approximate time logging - the project continues to grow. A call for help was sent out last month, and contributor activity is increasing - a new website, http://plaintextaccounting.org, has been created as a portal and knowledge base for hledger, Ledger, beancount and related tools and practices. Full release notes: http://hledger.org/release-notes#hledger-1.0 How to install: (Get stack, eg from http://haskell-lang.org/get-started) $ stack install --resolver=nightly hledger [hledger-ui] [hledger-web] [hledger-api] $ ~/.local/bin/hledger --version or see http://hledger.org/download for more install options, including cabal, OS packages and Windows binaries. Contributors to this release: Simon Michael, Dominik Süß, Thomas R. Koll, Moritz Kiefer, jungle-boogie, Sergei Trofimovich, Malte Brandy, Sam Doshi, Mitchell Rosen, Hans-Peter Deifel, Brian Scott, and Andrew Jones. How to get and give help: I hope you enjoy these tools and that they help you achieve your goals. The hledger project is by now too large for one person to do it justice, so it's great to see our contributor community growing. If you like hledger, your support and participation is welcome! Our IRC channel is #hledger on Freenode, and you can find out more at http://hledger.org <http://hledger.org/>. Best, -Simon

1 0

Escape Time Library or Free Software Program?
by Christopher Howard 30 Oct '16

30 Oct '16

Hi list. Is there a library that separates out escape time image generation, so that you could plug in whatever formula you wanted for Xnew and Ynew? (Instead of just a few predefined complex number formulas like julia?) I've come across a ton of libraries and programs that generate mandelbrots, but I wanted to try autogenerating images based on random polynomials, like Pickover describes in one of his papers. But I know escape time image generation must be far too well developed by now to be building this from scratch. -- https://qlfiles.net My PGP public key ID is 0x340EA95A (pgp.mit.edu)

1 0

Why doesn't GHC derive these types
by Clinton Mead 29 Oct '16

29 Oct '16

Consider the following program: {-# LANGUAGE TypeFamilyDependencies #-} data D x type family F t = s | s -> t type instance F (D t) = D (F t) f :: F s -> () f _ = () g :: D (F t) -> () g x = f x main = return () The problem seems to be the call from "g" to "f". We're calling "f" with an argument of type "D (F t)". "f" then has to determine what "s" is in it's signature. We know: 1. "F s ~ D (F t)" (from function call) 2. "D (F t) ~ F (D t)" (from the right hand side of the injective type definition) Therefore we should be able to derive: 3. "F s ~ F (D t)" (type equality is transitive) 4. "s ~ D t" (as F is injective) I suspect the part we're missing in GHC is step 4. I recall reading this somewhere but I can't find where now. However, the paper about injective types says that this style of inference, namely "F a ~ F b => a ~ b" should occur. I quote ( https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/injecti… section 5.1 p125): So, faced with the constraint F α ∼ F β, the inference engine does not in > general unify α := β; so the constraint F α ∼ F β is not solved, and hence > f (g 3) will be rejected. But if we knew that F was injective, we can unify > α := β without guessing. > Improvement (a term due to Mark Jones (Jones 1995, 2000)) is a process > that adds extra "derived" equality constraints that may make some extra > unifications apparent, thus allowing inference to proceed further without > having to make guesses. In the case of an injective F, improvement adds α ∼ > β, which the constraint solver can solve by unification. In general, > improvement of wanted constraint is extremely simple: > Definition 11 (Wanted improvement). Given the wanted constraint F σ ∼ F τ > , add the derived wanted constraint σn ∼ τn for each n-injective argument > of F. > Why is this OK? Because if it is possible to prove the original constraint > F σ ∼ F τ , then (by Definition 1) we will also have a proof of σn ∼ τn. So > adding σn ∼ τn as a new wanted constraint does not constrain the solution > space. Why is it beneficial? Because, as we have seen, it may expose > additional guess-free unification opportunities that that solver can > exploit. Am I correct in my assessment of what is happening here with GHC? Is there anyway to get it to compile this program, perhaps with an extension?

2 3

What instances can be derived by GHC ?
by Jacques Carette 29 Oct '16

29 Oct '16

I am trying to find a list of classes which can be derived 'out of the box' with GHC 8.0, i.e. without installing extra packages like derive [1]. There is quite a lot of information on how 'deriving' (inline and standalone) works [2] on the GHC wiki, but sadly no list. Yes, it does say that any class could be made derivable, but that's not useful, as it doesn't which ones have been. The page describing DerivingStrategies does have a list of 'stock classes' - is this indeed the full list? From the 8.0.1 documentation on Deriving [4], one can extract a list too. For reference, as far as I can tell, the answer to my question *appears to be* (using extensions as necessary): - Bounded, Enum, Eq, Ix, Ord, Read, Show, Functor, Foldable, Traversable, Generic, Generic1, Data, Lift. I do understand that GeneralizedNewtypeDeriving muddies the water. Let's ignore 'newtype' for this purpose, and only concentrate on 'data'. If my guess is correct, would it make sense to put this information somewhere easy to find, instead of having be buried, so that it needs to be 'dug out' ? Jacques [1] http://hackage.haskell.org/package/derive [2] https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/GenericDeriving [3] https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/DerivingStrategies [4] http://downloads.haskell.org/~ghc/8.0.1/docs/html/users_guide/glasgow_exts.…

2 1

Haddock, wrapping contexts?
by Tom Ellis 28 Oct '16

28 Oct '16

Some of my type signatures have long contexts and Haddock doesn't wrap them, pushing the more interesting information off the right hand side, e.g.: https://hackage.haskell.org/package/opaleye-0.5.1.1/docs/Opaleye-Join.html Is there any way I can convince Haddock to wrap these contexts? Ideally I want to see something like leftJoin :: (Default Unpackspec columnsA columnsA, Default Unpackspec columnsB columnsB, Default NullMaker columnsB nullableColumnsB) => Query columnsA -> Query columnsB -> ((columnsA, columnsB) -> Column PGBool) -> Query (columnsA, nullableColumnsB) Thanks, Tom

4 7

get Chalmers' Haskell Interpreter and Compiler source code
by Csaba Hruska 28 Oct '16

28 Oct '16

Hi, I was curious and wanted to check the HBC source code but I only found a broken link (https://www.haskell.org/hbc/hbc-2004-06-29.src.tar.gz) on Haskell Wiki <https://wiki.haskell.org/Implementations#HBI_and_HBC.2C_Chalmers.27_Haskell…> . Is it possible to fix the link? Or if somebody has the source code can you please share it? Thanks, Csaba

1 2

CoALP-Ty'16: Call for Participation
by František Farka 27 Oct '16

27 Oct '16

Call for Participation Workshop on Coalgebra, Horn Clause Logic Programming and Types 28-29 November 2016, Edinburgh, UK https://ff32.host.cs.st-andrews.ac.uk/coalpty16/ Abstract submission: 15 October, 2016 Registration deadline: 5 November, 2016 ==================================================== Objectives and scope ------------------- The workshop marks the end of the EPSRC Grant Coalgebraic Logic Programming for Type Inference, by K. Komendantskaya and J. Power and will consist of two parts: Part 1 - Semantics: Lawvere theories and Coalgebra in Logic and Functional Programming Part 2 - Programming languages: Horn Clause Logic for Type Inference in Functional Languages and Beyond We invite all colleagues working in related areas to present and share their results. We envisage a friendly meeting with many stimulating discussions, and therefore welcome presentations of already published research as well as novel results. Authors of original contributions will be invited to submit their papers to EPTCS post-proceedings. We especially encourage early career researchers to present and participate. Venue ----- The workshop will be held at the International Centre for Mathematical Sciences, in Edinburgh city centre, just 2 minutes walk from the Informatics Forum. Registration ------------ To register please fill in https://goo.gl/forms/KAm83p1bcNAxw0ss2 Although the registration is free it is compulsory. Please register by the 5th of November 2016. Programme --------- Monday 28 November 9:10 - 9:20 Registration 9:30 - 9:40 Welcome to CoALP-Ty'16 - Ekaterina Komendantskaya 9:40 - 11:10 Invited talk I - John Power: Logic Programming: Laxness and Saturation 11:10 - 11:30 Coffee break 11:30 - 12:00 Contributed talk - Henning Basold and Ekaterina Komendantskaya: Models of Inductive-Coinductive Logic Programs 12:00 - 13:00 Invited talk II - Steven Ramsay and Luke Ong: Refinement Types and Higher-Order Constrained Horn Clauses 13:00 - 14:00 Lunch 14:00 - 15:00 Invited talk III - Tarmo Uustalu: Comodels and Interaction 15:00 - 15:30 Coffee break 15:30 - 17:00 Contributed talks - František Farka: Proofs by Resolution and Existential Variables - Bashar Igried and Anton Setzer: Defining Trace Semantics for CSP-Agda - Clemens Kupke: Coalgebra and Ontological Rules 18:00 - 20:00 Workshop dinner - Lebanese restaurant Beirut, 24 Nicolson Square Tuesday 29 November 9:30 - 10:30 Invited talk IV - Claudio Russo: Classes for the Masses 10:30 - 11:00 Contributed talk - J. Garrett Morris: Semantical Analysis of Type Classes 11:00 - 11:30 Coffee break 11:30 - 12:30 Invited talk V - Davide Ancona: Abstract Compilation for Type Analysis of Object-Oriented Languages 12:30 - 13:30 Lunch 13:30 - 14:30 Invited talk VI - Ki Yung Ahn: Relational Specification of Type Systems Using Logic Programming 14:30 - 15:15 Discussion Panel - Horn Clause Logic: its Proof Theory, Type Theory and Category Theory — do we have the full picture yet? 15:15 - 15:45 Coffee break 15:45 - 16:45 Contributed talks - Martin Schmidt: Coalgebraic Logic Programming: Implementation and Optimization - Luca Franceschini, Davide Ancona and Ekaterina Komendantskaya: Structural Resolution for Abstract Compilation of Object-Oriented Languages Important dates --------------- Workshop registration: 5 November, 2016 Workshop: 28–29 November, 2016 Programme committee ------------------- Ki Yung Ahn, Nanyang Technological University, Singapore Davide Ancona, University of Genoa, Italy Filippo Bonchi, CNRS, ENS de Lyon, France Iavor Diatchki, Galois, Inc, USA Peng Fu, Heriot-Watt University, Edinburgh, UK Neil Ghani, University of Strathclyde, UK Patricia Johann, Appalachian State University, USA Ekaterina Komendantskaya, Heriot-Watt University, Edinburgh, UK Clemens Kupke, University of Strathclyde, UK J. Garrett Morris, University of Edinburgh, UK Fredrik Nordvall Forsberg, University of Strathclyde, UK John Power, University of Bath, UK Claudio Russo, Microsoft Research Cambridge, UK Martin Schmidt, DHBW Stuttgart and Osnabrück University , Germany Stephan Schulz, DHBW Stuttgart, Germany Aaron Stump, The University of Iowa, USA Niki Vazou, University of California, San Diego, USA Joe Wells, Heriot-Watt University, Edinburgh, UK Fabio Zanasi, Radboud University of Nijmegen, The Netherlands Workshop chairs -------- Ekaterina Komendantskaya, Heriot-Watt University, UK John Power, University of Bath, UK Publicity chair --------------- František Farka, University of Dundee, UK and University of St Andrews, UK -- František Farka

1 0

Fwd: How to best display type variables with the same name
by Christopher Done 27 Oct '16

27 Oct '16

Hi all, I posted the below to ghc-devs, but they suggested perhaps Haskell-Cafe might be interested in the problem. For convenience, here's the ghc-devs archive of that discussion: https://mail.haskell.org/pipermail/ghc-devs/2016-October/013085.html ---------- Forwarded message ---------- From: Christopher Done <chrisdone(a)gmail.com> Date: 19 October 2016 at 12:45 Subject: How to best display type variables with the same name To: "ghc-devs(a)haskell.org" <ghc-devs(a)haskell.org> We've encountered a problem in Intero which is that when inspecting types of expressions and patterns, sometimes it happens that the type, when pretty printing, yields variables of the same name but which have different provenance. Here's a summary of the issue: https://github.com/commercialhaskell/intero/issues/280#issuecomment-2547849… And a strawman proposal of how it could be solved: https://github.com/commercialhaskell/intero/issues/280#issuecomment-2547879… What do you think? Also, if I were to implement the strawman proposal, is it possible to recover from a `tyvar :: Type` its original quantification/its "forall"? I've had a look through the API briefly and it looks like a _maybe_. Ciao!

1 0

Proof of concept of explanations for instance resolution
by Michael Sloan 27 Oct '16

27 Oct '16

When typeclass machinery gets complicated, it can be hard to figure interpret the meaning behind GHC's messages. In particular "Could not deduce ..." messages often reference constraints that are deep in a tree of resolving typeclasses. I think it would be great if GHC provided additional information for this circumstance. In a way what we need is a "stack trace" of what GHC was thinking about when yielding these type errors. A couple years ago, I wrote an extremely hacky approach to yielding this information through TH. It is quite imperfect, and only works with GHC 7.8. I've realized that it's highly unlikely that this project will reach the level of polish for it to be very usable in practice: https://github.com/mgsloan/explain-instance However, rather than allow that work to be wasted, I'd like to bring people's attention to the problem in general, and how we might solve it in GHC. Along with providing more information in type errors, this could also look like having a ":explain" command in ghci. Lets take Text.Printf as an example. The expression (printf "%d %d" (1 :: Int) (2 :: A) :: String) has quite a bit of machinery behind it: printf :: (PrintfType r) => String -> r class PrintfType t instance (IsChar c) => PrintfType [c] instance (a ~ ()) => PrintfType (IO a) instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) class PrintfArg a where instance PrintfArg Int where With explain-instance, all we have to do is create a module with the following in it: import ExplainInstance import Text.Printf $(explainInstance [t| PrintfType (Int -> Int -> String) |]) Then, upon running the generated main function, we get the following explanation: instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) with a ~ Int r ~ (Int -> [Char]) instance PrintfArg Int instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) with a ~ Int r ~ [Char] instance PrintfArg Int instance IsChar c => PrintfType ([c]) with c ~ Char instance IsChar Char This is the recursive tree of instance instantiation! It shows the instance head, the particular types that it has been instantiated at in a made up "with" clause. Most importantly, it shows how the instance's constraints are also satisfied, giving a tree for an explanation. The implementation of this is irrelevant, but for the curious: it involves recursively reifying all of the typeclasses, and then generating a whole new set of typeclasses. These modified versions have the same heads (renamed) as the original typeclasses, but just have one method, which yields a description of the the types it has been instantiated with, via Typeable. Well that's quite convenient! I think it can really aid in understanding typeclass machinery to be able to get this variety of trace through what GHC is thinking when satisfying a constraint. However, this is just half the problem - what about type errors? I played around with a solution to this via UndecidableInstances, where it would create a base-case instance that represents the error case. Lets say I wanted to use (printf :: String -> A -> Int -> Maybe String) where A is a type that is not an instance of PrintfArg. Another issue with this is that the result type (Maybe String) is not allowed by PrintfType. The output of $(explainInstanceError [t| PrintfType (A -> Int -> Maybe String) |]) is instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) with a ~ A r ~ (Int -> Maybe [Char]) ERROR instance PrintfArg a with a ~ A instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) with a ~ Int r ~ Maybe [Char] instance PrintfArg Int ERROR instance PrintfType t with t ~ Maybe [Char] This explains exactly where the problem is coming from in the typeclass machinery. If you're just looking at the type of printf, and see a `PrintfType` constraint, it can be a total mystery as to why GHC is complaining about some class we may or may not know about: No instance for (PrintfArg A) arising from a use of ‘printf’ Thanks for reading! I hope we can address this UI concern in the future. I hope I've contributed something by demonstrating the possibility! -Michael

2 1

Suggestion for error message improvement
by Zachary Kessin 26 Oct '16

26 Oct '16

When I compiled some code this morning I got an error that said that I should edit my cabal file, but I notice that one thing is missing, the path to the cabal file. Having that in the error message would make fixing it a bit easier and faster in that emacs could take me right to the correct cabal file and that I would know for sure which one it was using. I tried filing this as a bug on the stack github repo but they said it is a ghc issue. [1 of 1] Compiling Main ( tests/test.hs, .stack-work/dist/x86_64-linux/Cabal-1.24.0.0/build/test/test-tmp/Main.o ) /home/zkessin/Documents/*****/tests/test.hs:17:1: error: Failed to load interface for ‘Control.Lens’ It is a member of the hidden package ‘lens-4.14’. Perhaps you need to add ‘lens’ to the build-depends in your .cabal file. Use -v to see a list of the files searched for. Progress: 1/2 -- While building package ***********-0.1.0.0 using: /home/zkessin/.stack/setup-exe-cache/x86_64-linux/setup-Simple-Cabal-1.24.0.0-ghc-8.0.1 --builddir=.stack-work/dist/x86_64-linux/Cabal-1.24.0.0 build lib:********** test:test --ghc-options " -ddump-hi -ddump-to-file" Process exited with code: ExitFailure 1 -- Zach Kessin SquareTarget <http://squaretarget.rocks?utm_source=email-sig> Twitter: @zkessin <https://twitter.com/zkessin> Skype: zachkessin

2 1

[ANN] unicode-transforms-0.2.0 pure Haskell unicode normalization
by Harendra Kumar 25 Oct '16

25 Oct '16

Hi, I released unicode-transforms sometime back as bindings to a C library (utf8proc). Since then I have rewritten it completely in Haskell. Haskell data structures are automatically generated from unicode database, so it can be kept up-to-date with the standard unlike the C implementation which was stuck at unicode 5. The implementation comes with a test suite providing 100% code coverage. After a number of algorithmic and implementation efficiency optimizations, I was able to get several times better decompose performance compared to the C implementation. I have not yet got a chance to fully optimize the compose operations but they are still as fast as utf8proc. I would like to thank Antonio Nikishaev for the unicode character database parsing code which I borrowed from the prose library. https://github.com/harendra-kumar/unicode-transforms https://hackage.haskell.org/package/unicode-transforms -harendra

2 2

A composable, local graph representation as an open discussion
by David Rogers 25 Oct '16

25 Oct '16

Haskell-Cafe: I have been working on the following idea, and would appreciate any comments on the novelty or usefulness in your own applications. A scan of the usual Haskell documents turns up lots of clever data structures, but nothing particularly enlightening for graphs. Here is my attempt: Graphs are difficult to represent in functional languages because they express arbitrary undirected connectivity between nodes, whereas functional code naturally expresses directed trees. Most functional algorithms for graphs use an edge-list with global labels. Although effective, this method loses compositionality and does not exploit the type system for enforcing graph invariants such as consistency of the edge list. This note presents a functional method for constructing a local representation for undirected graphs functionally as compositions of other graphs. The resulting data structure does not use unique node labels, but rather allows edge traversal from any node to its neighbor through a lookup function. Graph traversal then emerges as a discussion among static nodes. I have found this method useful for assembling sets of molecules in chemical simulations. It's also an interesting model for framing philosophical questions about the measurement problem in quantum physics. As a disclaimer, although it is useful for constructing graphs, it is not obvious how common operations like graph copying or node deletion could be performed. This note does not discuss how to implement any graph algorithms. > import qualified Prelude > import Prelude hiding ((.)) > import Data.Semigroup(Semigroup,(<>)) > import Data.Tuple(swap) First, I change the meaning of "." to be element access. I think this is a cleaner way to work with record data, and suggest that there should be a special way to use this syntax without making accessor names into global variables. > infixl 9 . > a . b = b a -- switch to member access Every subgraph has open ends, which we just number sequentially from zero. The lookup function provides the subgraph's window to the outside world. Its inputs reference outgoing connections. A subgraph, built as a composite of two subgraphs, will have the job of providing the correct lookup environment to both children. > type Conn = Int > newtype Lookup l = Lookup ( Conn -> (l, Lookup l) ) The tricky part is making the connections between the internal and external worlds. For the internal nodes to be complete, they must have access to complete external nodes. The problem is reversed for the external nodes. A naive idea is to represent a graph using a reader monad parameterized over label and result types (l,r). -- newtype Grph l r = Reader (Int -> (l, Lookup)) r Unfortunately, this breaks down because the outside world also needs to be able to `look inside' the subgraph. The above approach runs into trouble when constructing the lookup function specific to each child. That lookup function needs the outside world, and the outside world can't be completed without the ability to look inside! We capitulate to this symmetry between the graph and its environment by using a representation of a subgraph that provides both a top-down mechanism for using the graph as well as a bottom-up representation of the subgraph to the outside world. > data Grph l r = Grph { runGrph :: Lookup l -> r, > self :: Conn -> Lookup l -> (l, Lookup l), > nopen :: Int > } The default action of `running' a graph is to run a local action on each node. That local function has access to the complete graph topology via the lookup function. Since we expect this to be a fold, the result type will probably be a monoid, or at least a semigroup. Any sub-graph can be run by specifying what to do with incomplete connections. At the top-level, there should not be `open' connections. >--run g = (g.runGrph) $ Lookup (\ _ -> error "Tried to go out of top-level.") > run g = (g.runGrph) $ u > where u = Lookup $ \ _ -> ("end", u) Individual nodes are themselves subgraphs. Nodes must specify how many external connections can be made, as well as an arbitrary label and an action. > node :: Int -> l -> ((l, Lookup l) -> r) -> Grph l r > node n l run = Grph (\e -> run (l, e)) (\_ e -> (l, e)) n Arbitrary graphs are constructed by joining two subgraphs. The key here is the construction of separate lookup environments for the each subgraph. The left subgraph can be connected to the first few openings in the environment or to the right subgraph. The right subgraph can connect to the last few openings of the environment, or to the left subgraph. Each time an edge is traversed, a series of "env" calls are made -- sweeping upward until an internal connection happens. Then a downward sweep of "self" calls are made. This takes at best O(log|nodes|) operations. Connections are specified by (Conn,Conn) pairs, so we need the ability to lookup from the permutation or else to return the re-numbering after subtracting connections used by the permutation. > type Permut = [(Conn, Conn)] > find_fst :: Conn -> Permut -> Either Conn Conn > find_fst = find1 0 where > find1 n a ((a',b):tl) | a == a' = Left b -- internal > find1 n a ((a',_):tl) | a' < a = find1 (n+1) a tl > find1 n a (_:tl) = find1 n a tl > find1 n a [] = Right (a-n) -- external > find_snd b p = find_fst b (map swap p) >-- append 2 subgraphs > append :: (Semigroup r) => Permut -> Grph l r -> Grph l r -> Grph l r > append p x y = Grph { runGrph = \(Lookup env) -> > (x.runGrph) (e1 env) > <> (y.runGrph) (e2 env), > self = down, > nopen = (x.nopen) + (y.nopen) - 2*(length p) > } > where > down n (Lookup env) | n < ystart = (x.self) n (e1 env) > down n (Lookup env) = (y.self) (n-ystart) (e2 env) > e1 env = Lookup $ \n -> case find_fst n p of > Right m -> env m > Left m -> (y.self) m (e2 env) > e2 env = Lookup $ \n -> case find_snd n p of > Right m -> env (m+ystart) > Left m -> (x.self) m (e1 env) > ystart = (x.nopen) - length p -- start of b's env. refs This is a helper function for defining linear graphs. > instance Semigroup r => Semigroup (Grph l r) where > (<>) = append [(1,0)] A simple action is just to show the node labels and the labels of each immediate neighbor. > show_node (l, Lookup env) = " " ++ show l > show_env (l, Lookup env) = show l > ++ foldl (++) (":") (map (\u -> show_node(env u)) [0, 1]) > ++ "\n" The following example graphs are a list of 4 single nodes, two incomplete 2-member chains, and a complete 4-member cycle. The key feature here is that that the graphs are all composable. > c6 = [ node 2 ("C"++show n) show_env | n <- [1..4] ] > str = c6!!0 <> c6!!1 > str' = c6!!2 <> c6!!3 > cyc = append [(1,0), (0,1)] str str' -- Tying the knot. > main = putStrLn $ run cyc The connection to the measurement problem in quantum physics comes out because the final output of running any graph is deterministic, but can depend nontrivially on the graph's environment. Like links in the graph, physical systems communicate through their mutual interactions, and from those determine a new state a short time later. In a closed universe, the outcome is deterministic, while for any an open system (subgraph), the outcome is probabilistic. The analogy suggests that understanding how probabilities emerge in the measurement problem requires a two-way communication channel between the system and its environment. ~ David M. Rogers

4 4

What did you/do you find hard/dislike about Opaleye?
by Tom Ellis 25 Oct '16

25 Oct '16

I'm planning to update and refresh Opaleye's documentation and add some new functionality for common use cases. To help with this I'd like to request input from anyone who has ever tried the library. Specifically, what do you (or did you) find hard about using Opaleye and what did you dislike about it? If you tried it and gave up, what was the major sticking point? I'm already aware that many people dislike the boilerplate involved in defining your tables and types, and the polymorphic products are particularly uncomfortable for some. You don't need to mention these issues unless you particularly want to! Feel free to contact me privately or reply directly. Many thanks. Tom

2 3

Left Associativity and Precendence
by Steven Leiva 23 Oct '16

23 Oct '16

Hi folks, Haskell beginner here. I ran across the expression below (from the Haskell Programming From First Principles <http://www.haskellbook.com> book), and I was having a hard time putting parenthesis around the expression in order to make the order of application more explicit. Here is the expression in question: *take 5 . filter odd . enumFrom $ 3* I realize that part of the hang-up that I was having was that I focused solely on the fact that function application is left-associative, and not on the fact that specific functions / operators can have a declared precedence. Once I realized that the $ operator has a declared precedence of 0, the expression took on the following form: *(take 5 . filter odd . enumFrom) $ (3)* Now, everything to the left of the $ operator is simply function application (whitespace) and the function composition operator. I made the same mistake again of ignoring the fact that particular functions / operators can have a declared precedence. Realizing that mistake, and that the function composition has a declared precedence of 9, then the expression took on this form: *((take 5) . (filter odd) . (enumFrom)) $ (3)* So, the general rule that I took away from this is that, when trying to imagine how an expression reduces to normal form, function application does indeed proceed from left to right, but we have to take into account the declared precedence of particular functions / operators. Is my thinking correct here? Are there any particular holes in this logic? I still don't think I'd be able to figure out "where the parenthesis go" if I was given a new expression with functions / operators with 3 or 4 different declared precedences. For a beginner, is that a huge problem, or is knowledge of the concept enough?

3 2

Off-the-shelf Configurable BFT
by Jonn Mostovoy 23 Oct '16

23 Oct '16

Dear all, we're implementing a variant of cryptocurrency with deleged forgers. It is distributed in building ledger and decentralized in nodes participating jn forming transactions. For this we would need to have a BFT algorithm to govern the views on the network and deal with partitions. Implementation has to be industrial-strength and used in production. We're willing to contribute actively to such implementation development. We're looking at HoneyBadgerBFT as an ideal candidate, but it's not implemented in Haskell. The only BFT algorithm implementation we found is a toy RaftBFT implementation. If you have an opensource BFT implementation, or proprietary BFT implementation you would like to trade, please report those implementations here. If you need more details on our use case, don't hesitate to ask. Everything we do is open source and me or my colleagues will gladly answer any questions you might have. Sincerely yours, Jonn Mostovoy, Cardano SL Project Managet at IOHK | Serokell https://serokell.io https://iohk.io

3 2

Wiki account Request
by Siddharth Bhat 23 Oct '16

23 Oct '16

Hey, I'd like a wiki account to edit the Template Haskell pages (the links to the user guide are broken) preferred username: bollu Also, I think it's a little ridiculous to have this be a closed thing (I can't simply register to the wiki). Shouldn't the barrier to entry be _lowered_? Thanks, Siddharth -- Sending this from my phone, please excuse any typos!

5 4

Obtaining location of subexpressions from Template Haskell
by Alejandro Serrano Mena 23 Oct '16

23 Oct '16

Dear Haskell-café, I am trying to write a small TH module which manipulates Haskell code. Basically, I have a function `transform :: Exp -> Q Exp` which I call this way: > g = $(transform [| map (+1) [1,2,3] |]) Since this is a source-to-source transformation, I would like to generate also {-# LINE ... #-} pragmas to point any error back to their original location. My question is: is there any way to obtain the location of sub-expressions inside a `Exp` or `Q Exp`? Thanks in advance, Alejandro

2 1

Munich Haskell Meeting, 2016-10-25 @ 19:30
by Christian Neukirchen 22 Oct '16

22 Oct '16

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Tuesday, October 25 at **Augustiner-Gaststätte Rumpler (Baumstraße 21)** at 19h30. Please note the new location! For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself quickly to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-oct-2016/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Request for help w/ Ex. 10 in *Arrows and Computation*.
by David Banas 22 Oct '16

22 Oct '16

Hi all, I’m stuck in Ex. 10 of *Arrows and Computation*, by Ross Paterson: https://htmlpreview.github.io/?https://github.com/capn-freako/Haskell_Misc/… <https://htmlpreview.github.io/?https://github.com/capn-freako/Haskell_Misc/…> It seems to me that if, in the third step of my proof, I could convert the *left (pure fst)* into *left (first <?>)*, then I could use the **distribution** axiom to convert *pure distr >>> left (first <?>)* into *first (left <?>) >>> pure distr *. At that point, I would have (starting from the left side of my expression): *first (..) >>> first (..)*, and could apply the functor property of *first*, in order to simplify the expression. Thanks, -db

1 0

[ANN] patat - Terminal based presentation tool built with Pandoc
by Jasper Van der Jeugt 20 Oct '16

20 Oct '16

I'm happy to announce `patat` (Presentations Atop The ANSI Terminal), a small tool that allows you to show presentations using only an ANSI terminal. The main features are: - Leverages the great Pandoc library to support many input formats including Literate Haskell. - Supports smart slide splitting. - There is a live reload mode. - Theming support. - Optionally re-wrapping text to terminal width with proper indentation. - Written in Haskell. You can find more information here: https://github.com/jaspervdj/patat/blob/master/README.md Peace, Jasper

15 22

I cannot seem to get the second aio command to work on Create a Game with Haskell hgamer3D.org
by KC 20 Oct '16

20 Oct '16

I'm getting an error 403 permission denied aio http://www.hgamer3d.org/component/CreateProject arriccio is going to download and install the following files: -------------------------------------------------------------- (more license info can be obtained by using the "aio license" cmd) file: http://www.hgamer3d.org/downloads/lua-amd64-windows-1.0.0.tar.gz signing key: https://www.github.com/urs-of-the-backwoods.keys license: MIT License please confirm download with "yes": yes downloading: http://www.hgamer3d.org/downloads/lua-amd64-windows-1.0.0.tar.gz2016/10/20 11:23:56 cannot download urln: http://www.hgamer3d.org/downloads/lua-amd64-windows-1.0.0.tar.gz, http error: 403 -- -- Sent from an expensive device which will be obsolete in a few months! :D Casey

1 0

PEPM 2017 Call for Poster Papers (submission deadline Tuesday 8th November)
by Jeremy Yallop 20 Oct '16

20 Oct '16

CALL FOR POSTERS Workshop on PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM 2017) PEPM 2017 information: http://conf.researchr.org/home/PEPM-2017 Submissions: https://pepm17.hotcrp.com/ Paris, France, January 16th - 17th, 2017 (co-located with POPL 2017) PEPM is the premier forum for discussion of semantics-based program manipulation. The first ACM SIGPLAN PEPM symposium took place in 1991, and meetings have been held in affiliation with POPL every year since 2006. PEPM 2017 will be based on a broad interpretation of semantics-based program manipulation, reflecting the expanded scope of PEPM in recent years beyond the traditionally covered areas of partial evaluation and specialization. Posters ------- In order to maintain the dynamic and interactive nature of PEPM, we solicit submission of posters. Poster submissions are 2-page articles in ACM Proceedings style that present preliminary work (see "Submission guidelines" below for more details). If accepted, the work will be presented as part of an interactive poster session at PEPM. Scope ----- Topics of interest for PEPM 2017 include, but are not limited to: * Program and model manipulation techniques such as: supercompilation, partial evaluation, fusion, on-the-fly program adaptation, active libraries, program inversion, slicing, symbolic execution, refactoring, decompilation, and obfuscation. * Program analysis techniques that are used to drive program/model manipulation such as: abstract interpretation, termination checking, binding-time analysis, constraint solving, type systems, automated testing and test case generation. * Techniques that treat programs/models as data objects including metaprogramming, generative programming, embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation. * Application of the above techniques including case studies of program manipulation in real-world (industrial, open-source) projects and software development processes, descriptions of robust tools capable of effectively handling realistic applications, benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, embedded and resource-limited computation, and security. This list of categories is not exhaustive, and we encourage submissions describing applications of semantics-based program manipulation techniques in new domains. If you have a question as to whether a potential submission is within the scope of the workshop, please contact the programme chairs. Submission guidelines --------------------- * Posters should describe work relevant to the PEPM community, and must not exceed 2 pages in ACM Proceedings style. We invite poster submissions that present early work not yet ready for submission to a conference or journal, identify new research problems, showcase tools and technologies developed by the author(s), or describe student research projects. If accepted, the work will be presented as part of an interactive poster session at PEPM. At least one author of each accepted contribution must attend the workshop and present the work. Student participants with accepted poster papers can apply for a SIGPLAN PAC grant to help cover travel expenses and other support. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC programme, see its web page. Publication ----------- Posters will appear along with accepted papers in formal proceedings published by ACM Press and in the ACM Digital Library. Keynote ------- Neil Jones (DIKU) will give the PEPM keynote talk, titled Compiling Untyped Lambda Calculus to Lower-level Code by Game Semantics and Partial Evaluation Submission ---------- Posters should be submitted electronically via HotCRP. https://pepm17.hotcrp.com/ Authors using LaTeX to prepare their submissions should use the new improved SIGPLAN proceedings style, and specifically the sigplanconf.cls 9pt template. Important Dates --------------- * Poster submission : Tuesday 8th November 2016 * Author notification : Friday 18th November 2016 * Camera ready : Monday 28th November 2016 * Workshop : Monday 16th - Tuesday 17th January 2017 The proceedings will be published 2 weeks pre-conference. AUTHORS TAKE NOTE: The official publication date is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of your conference. The official publication date affects the deadline for any patent filings related to published work. (For those rare conferences whose proceedings are published in the ACM Digital Library after the conference is over, the official publication date remains the first day of the conference.). PEPM'17 Programme Committee --------------------------- Elvira Albert (Complutense University of Madrid, Spain) Don Batory (University of Texas at Austin, USA) Martin Berger (University of Sussex, UK) Sebastian Erdweg (TU Delft, Netherlands) Andrew Farmer (Facebook, USA) Matthew Flatt (University of Utah, USA) John Gallagher (Roskilde University, Denmark) Robert Glück (DIKU, Denmark) Jurriaan Hage (Utrecht University, Netherlands) Zhenjiang Hu (National Institute of Informatics, Japan) Yukiyoshi Kameyama (University of Tsukuba, Japan) Ilya Klyuchnikov (Facebook, UK) Huiqing Li (EE, UK) Annie Liu (Stony Brook University, USA) Markus Püschel (ETH Zurich, Switzerland) Ryosuke SATO (University of Tokyo, Japan) Sven-Bodo Scholz (Heriot-Watt University, UK) Ulrik Schultz (co-chair) (University of Southern Denmark) Ilya Sergey (University College London, UK) Chung-chieh Shan (Indiana University, USA) Tijs van der Storm (Centrum Wiskunde & Informatica, Netherlands) Jeremy Yallop (co-chair) (University of Cambridge, UK) -- Ulrik Pagh Schultz, Associate Professor, University of Southern Denmark ups(a)mmmi.sdu.dk http://www.sdu.dk/ansat/ups +4565503570

1 0

MTL vs Free-monads, what are your experiences
by Damian Nadales 20 Oct '16

20 Oct '16

Hi, I was looking into free monads for designing a DSL for describing scenarios of the form: scenario = do aId <- createA b0Id <- createB id b1Id <- createB id link b0 b1 In our company we use a graph database, and currently we're setting up the test data using raw queries O.O So I wanted to come up with a better abstraction, and also enable us to do property based testing (by testing on random scenarios like the one above). Anyway, I ran into this presentation: http://www.slideshare.net/jdegoes/mtl-versus-free http://degoes.net/articles/modern-fp-part-2 In which monad transformers and free monads are compared. Do you have any experience using any of these approaches. If so would you mind sharing? ;) Thanks! Damian

12 19

Re: [Haskell-cafe] Why does [1.0, 3 ..4] contain 5?
by Bence Kodaj 20 Oct '16

20 Oct '16

Silvio, Brandon, Ben: thanks for your instructive comments. Please allow me to dwell on this issue for 5 more minutes - I'm really interested in your opinion. Do you think it would be bad if we changed the definition of numericEnumFromThenTo e1 e2 e3 in such a way that the resulting list would never contain elements that are greater than e3 (in the e1 <= e2 case)? I'm asking because you can actually be bitten by this quirk of enumerated lists of Doubles (and Floats) even if you don't use floating-point literals explicitly. Consider the following (this is how I stumbled upon this issue actually): -- "odd semi-factorial" of n osf n = product [1, 3 .. n] -- "even semi-factorial" of n esf n = product [2, 4 .. n] Load this into GHCi and then go: *Main> osf 4 3 *Main> esf 4 8 *Main> osf 4 / esf 4 1.875 This last result looks total nonsense at first glance - it took me a good 15 minutes to realize what was going on. Of course, if I provide reasonable type signatures (e.g., Integer -> Integer) for osf and esf, then the problem goes away. Still, to me this strange result is a lot more surprising and unexpected than the fact that e.g., [1.0, 1.1 .. 2.3] would not actually contain (a value close to) 2.3 if we changed the definition of numericEnumFromThenTo. After all, it's fairly common knowledge that floating-point arithmetic is inexact and you're not supposed to rely on precise equality of two floating-point values, or you shouldn't be surprised if basic mathematical identities don't hold for floating-point values (e.g., 1 + 2*0.1 /= 1 + 0.1 + 0.1). Whereas the apparent "change" in the value of osf 4 from one line to the next above is more baffling I believe. But what do you think? Regards, Bence

1 0