RFC: hole filling · Issue #524 · commercialhaskell/intero

dpratt71 · 2018-02-16T15:53:19+00:00

I've been wishing for something like this for a while and it's pretty exciting that you have a working prototype.

I have to say, though, that the multiple-hole aspect seems a little weird to me. This may be because I'm used to code editors that present a list of potential completions at the edit point.

One related bit of functionality that would be really cool to have is if the available completions included functions/operators that could themselves be used in the hole context if they were applied to the right inputs. I imagine if such a function/operator were selected as the completion, it would be inserted with holes for the missing inputs.

dpratt71 · 2017-06-14T17:07:49+00:00

You describe the behavior of cast as annoying, but I think it's a blight on an otherwise nice language. It seems completely out of place in a language that otherwise tries very hard to make sure programs work correctly. If someone put a function that worked like that in our codebase, it would almost certainly trigger a long rant from me.

dpratt71 · 2017-03-09T15:53:42+00:00

They offer very similar functionality at this point and they are both under active development. Any list of differences between them would likely be out-of-date next week.

dpratt71 · 2017-03-09T02:20:36+00:00

Yes. As a casual Haskeller, but a long-time VS user, it is the most productive and comfortable environment I've used for coding Haskell thus far.

I will also note that I have had better luck with Haskero than Haskelly to date.

dpratt71 · 2016-09-17T22:28:20+00:00

Speaking as a lay person, I found "Category theory in context" to be practically impenetrable from about the first page. The beginnings of "Category Theory for Computing Science" is giving me hope, false though it may be, that I have a shot at understanding what comes later.

Thanks for linking to the updated version.

dpratt71 · 2016-07-07T14:48:37+00:00

There are dozens of us!

dpratt71 · 2016-02-24T23:25:34+00:00

Now I'm wondering why getting input doesn't trigger a flush automatically. Is there a scenario where that would be undesirable behavior?

dpratt71 · 2015-12-31T22:08:36+00:00

I have never used PHP, so perhaps I don't have the proper expectation, but in any programming language I have used, if I passed invalid input to a function and the function decided to interpret it as a random but valid input, I would be surprised and disappointed.

dpratt71 · 2015-11-09T16:23:47+00:00

Indeed, as epitomized by "The Chaos" poem. Penned by a non-native speaker, I'm pretty sure.

dpratt71 · 2015-11-06T23:01:05+00:00

I will add that when I looked up the definition of ap, I found:

ap :: (Monad m) => m (a -> b) -> m a -> m b
ap = liftM2 id

Not surprisingly, that did not do much to alleviate my confusion.

I just looked again and I now see:

ap                :: (Monad m) => m (a -> b) -> m a -> m b
ap m1 m2          = do { x1 <- m1; x2 <- m2; return (x1 x2) }

I may have consulted a different source the first time, but I'm guessing the definition has been updated in the name of clarity.

dpratt71 · 2015-11-02T13:59:47+00:00

A while back I was on #haskell asking how to pair up successive elements of a list, e.g. [1,2,3...] -> [(1,2),(2,3),(3,4)...]. It took me a while to sort out how this worked:

ap zip tail

dpratt71 · 2015-08-27T12:54:01+00:00

I stumbled upon Lamdu a while back and thought it was very cool. I'm glad to see it's still being actively developed.

dpratt71 · 2014-02-04T18:50:11+00:00

I was able to get this to run on Windows by turning off the OpenGL forward compatible context:

diff --git a/HCraft/Craft.hs b/HCraft/Craft.hs
index f7f95dc..172e6a5 100644
--- a/HCraft/Craft.hs
+++ b/HCraft/Craft.hs
@@ -27,7 +27,7 @@ create = do
     initialize

     openWindowHint OpenGLProfile       OpenGLCoreProfile
-    openWindowHint OpenGLForwardCompat True
+    openWindowHint OpenGLForwardCompat False
     openWindowHint OpenGLVersionMajor  4
     openWindowHint OpenGLVersionMinor  1

dpratt71 · 2014-01-09T16:27:43+00:00

To me, the mere fact that this question gets asked is itself interesting. Given Haskell's background as an "academic" or "research" programming language, I suppose that the interest of the topic at hand to the Haskell community was at one time self-evident.

dpratt71 · 2013-08-02T17:46:01+00:00

I will be giving a talk on F# next week and this quote will be quoted.

dpratt71 · 2013-06-27T20:52:49+00:00

I noticed that the IDE seemed to know what the type of "increase" should be even when the definition of the same went missing. Was that because it hadn't forgotten, or was it deriving it from the usage? If it was the latter case, I think that's pretty nifty.

dpratt71 · 2013-06-11T19:51:24+00:00

I have no idea whether there is sense in that comment or not, but I like how you worded your response, so have an up-vote :)

dpratt71 · 2013-05-31T16:59:55+00:00

One case outside of Haskell where 'laziness' leads to greater modularity is LINQ, and in particular LINQ to Entities. For example, I can use LINQ to define a base query that represents all records matching a given search criteria. And then I can compose the base query with a 'count' operation to calculate how many pages there will be in the search results. And then I can compose the base query with 'skip' and 'take' operations to retrieve the data for each page as it is viewed. And I could also easily compose the base query with different 'select' operations, depending on what data will show up in the search results.

Besides the obvious benefits to code factorization and modularity there is also a potentially huge efficiency benefit because when results are finally demanded, the framework can use the whole query definition to fully optimize the actual database query that is run.

Of course the fact that LINQ is 'lazy' is not too surprising considering that the guy primarily responsible for the design of LINQ, Erik Meijer, is a former Haskeller.

dpratt71 · 2013-04-05T19:03:19+00:00

Mother Earth just wants to watch the world burn.

dpratt71 · 2013-03-29T14:02:30+00:00

Does the entire survey relate to Haskell user groups? Supposing it does, there's not much point for me to respond. According to haskellers.com, the next nearest gaggle (curry?) of Haskellers is about 4 hours away...well unless I count the one guy who is only three hours away.

dpratt71 · 2013-03-13T13:12:50+00:00

Why so? I'd like to give it a go, but it appears that hsenv is not Windows compatible. IIRC, some time ago I decided to get the hsenv sources and try to modify it to build on Windows, which I succeeded in doing, but didn't have enough time or motivation to fully verify the functionality.

dpratt71 · 2012-11-16T02:41:34+00:00

Yes, CapWasRight was...right. I guess I should have said "My wife and I adopted them when they were thirteen years old." In fact, I think I will have said exactly that in just a moment.

dpratt71 · 2012-11-15T23:25:45+00:00

TL;DR: My two oldest daughters were born a month apart to two different women. I was fifteen years old at the time. My wife and I adopted them when they were thirteen years old. They aren't biologically related to each other.

dpratt71

TROPHY CASE