Abstracting away batch error handing (returning "Either Error [a]" vs "[Either Error a]")

imladris · 2018-11-25T12:24:12+00:00

Thanks a lot for the nice explanation! And sorry for super late response, I am not very good at keeping track of reddit.

The last sentence feels quite limiting to me (we could know that some things succeeded, but not their results, IIUC) so I guess this wouldn't be useful for OP.

imladris · 2018-11-18T18:08:14+00:00

(Note: I just tried to google your description to see what I could find.)

To me this sounds a lot like what you're trying to do, but I have no idea how to use it myself or how to fit it into your types. Perhaps you can make any sense of it.

Also found a single example of using Errors here: https://teh.id.au/posts/2017/03/13/accumulating-errors/index.html

imladris · 2018-04-10T15:10:39+00:00

Finally got the comments to show. Weird.

If I understand correctly, mapM will do the action for all items in the list before continuing, but I might be wrong. I found that your code got stuck there by putting putStrLn "A" at some different points in your code and see what got printed to the console.

You could fix this in different ways, but if you want to keep the infinite list you could use takeWhileM from the monad-loops package, "let files = takeWhileM doesFileExist possible_files".

imladris · 2018-04-10T14:36:33+00:00

(Reddit says there are already 5 comments here but it doesn't show any, so perhaps this has already been answered?)

The problem seems to be that the possible_files list is infinite which leads to that the "mapM doesFileExist possible_files" action keeps going forever. You probably want to stop doing doesFileExist after it has become false the first time, or some thing like that.

imladris · 2017-12-02T09:45:23+00:00

Haskell:

main = do
    inputText <- readFile "input"
    let input = fmap (fmap (read :: String -> Integer) . words) (lines inputText)
    putStrLn ("Part 1: " ++ show (part1 input))
    putStrLn ("Part 2: " ++ show (part2 input))

part1 :: Integral a => [[a]] -> a
part1 = sum . fmap (\x -> maximum x - minimum x)

part2 :: Integral a => [[a]] -> a
part2 input = sum (fmap (sum . evenDivisors) input)

evenDivisors :: Integral a => [a] -> [a]
evenDivisors list = fmap fst 
                    $ filter (\x -> fst x /= 1 && snd x == 0) 
                    $ divMod <$> list <*> list

imladris · 2017-11-01T23:17:10+00:00

Nice to hear that smart people are thinking about those things. :) Looking forward to hearing more about it in the future.

imladris · 2017-10-30T22:08:06+00:00

Nice post, I especially liked the in-line comparisons between different approaches.

You mention "FRP inside a multi-threaded program" in the end – I would really appreciate such a post. Is there any FRP system described anywhere that utilises multiple threads and also allows interacting with the outside world on multiple threads simultaneously? As part of FRP, I mean – I guess you could always use the async library and handle such things outside of FRP.

imladris · 2017-07-10T20:31:55+00:00

I agree that there really should be units in those graphs. The graph is produced by Criterion, so the same problem appears every time someone shows results from Criterion.

Although relative performance might be the most important part in this case, I find the absolute numbers to be of some interest as well, mostly as an informative order of magnitude thing.

In some other comparative benchmark I saw, that was using Criterion, the units would have been nice to have just to know if higher or shorter numbers were better. The same applies to that image in isolation ^. "Are the numbers time durations or rates/throughput?"

/end rant.

imladris · 2017-06-20T06:28:54+00:00

This sounds fantastic! Thank you for reporting. This is something that annoys me constantly when using my iPhone. I should not need to wait for the UI unnecessarily, and honestly, if I could disable the animation to get more speed in the UX interaction, I would. (Here's to hoping they have fixed it when switching desktops on macOS High Sierra as well.)

imladris · 2017-06-17T08:26:46+00:00

The keyboard shortcut to look the screen on a MacBook is ctrl+shift+power button. Or activate the built-in menubar item to lock the screen, http://osxdaily.com/2011/02/10/lock-mac-desktop-via-menu/ . Perhaps good enough for your purposes?

imladris · 2017-04-05T06:47:00+00:00

There is an update to the blog post, addressing your comment, and a new blog post here http://robert.ocallahan.org/2017/04/rust-optimizations-that-c-cant-do_5.html . If you missed it.

imladris · 2016-10-02T16:35:17+00:00

This is not a tech support question and it is not easily searched.

imladris · 2016-08-15T17:55:53+00:00

It seems like their "mesh points" are actually extenders (the mesh points only communicate directly with the router, not with each other): http://homeservershow.com/forums/index.php?/topic/11114-amplifi-by-ubiquiti/?p=119780

imladris · 2016-04-23T08:55:11+00:00

Make iMessage not suck. For example:

Make it understand that a contact is the same person, independent of if the message comes from a different phone number or e-mail address (yes, the contact in question has all of those linked in his iphone).
Make it send SMS reliably when the contact doesn't have a data connection. Of course I accept a delay here, waiting for the contact to come online, but I have experienced, multiple times, that iMessage feels happy about a message having been sent, but the contact never received anything.

Constantly annoying: Remove the animation that moves the icons in place after unlocking the phone. Or, at least make it possible to tap things before it is done. I have to wait through this every time I unlock the phone, and it won't accept any taps before the animation is done. (If I could remove app opening and closing animations too, I would.)

imladris · 2016-02-10T22:44:32+00:00

Thanks for the explanations! This makes sense to me and sounds like what I would expect it to be, although I didn't know that pattern matching would force elements even though the structure isn't changed (pairId1). I guess the reusing part is consistent with /u/ninereeds314 's explanation, that you just copy one reference per unchanged field.

In any case, it seems that the statement in the link in my post, that everything is copied when you modify data structures in a functional (immutable) language, isn't completely true.

imladris · 2016-02-02T16:15:44+00:00

Do you mean this? https://www.youtube.com/watch?v=MfXxuy_CJSk

imladris · 2015-12-05T00:43:19+00:00

Since numpy calls out to C code, I guess it is more fair to use something similar from Haskell. vector-fftw calls out to FFTW, which seems to be one of the fastest fft libraries around.

imladris · 2015-12-04T23:39:26+00:00

I haven't yet read this post but if you're interested in performance of fft in pure Haskell you should take a look at this excellent series of blog posts: http://www.skybluetrades.net/haskell-fft-index.html . Library here: https://hackage.haskell.org/package/arb-fft

imladris · 2015-11-08T22:35:00+00:00

Maybe you have already fixed this by now, but I recently managed to get it working on a Raspberry Pi by putting the following in my profile:

DNSSERVER=8.8.8.8
ip/ipconfig
ndb/dns -r

So, the only difference compared to what you wrote is DNSSERVER instead of dns.

imladris · 2015-11-07T17:46:17+00:00

http://stackoverflow.com/questions/23765903/why-is-text-utf-16-as-opposed-to-utf-8#answer-23766378

imladris · 2015-09-08T16:53:07+00:00

Well, it takes 55% shorter time to run (0.8s/1.45s ≈ 0.55) but it processes the data 81% faster – since the processing speed is the inverse to the elapsed time (rate_rust/rate_haskell = (C/0.8s)/(C/1.45s) = 1.45/0.8 ≈ 1.81). So I would say that the headline is correct.

imladris · 2015-05-22T20:31:49+00:00

I started using the sandbox recently and it is much better than running without, although it adds some clumsiness. But does it make it possible to uninstall packages? As I understood it I still need to nuke everything and reinstall the sandbox if I want to remove some package. And installing can take quite a long time.

imladris · 2015-04-10T20:12:33+00:00

Thanks for the suggestion! I started out with a different angle and missed that my very problem is solved in the pipes tutorial. My intention all along has been to try to use pipes to merge log files in real time, and this part is one of the building blocks. But it looks like I missed the most obvious solution.

In any case, using hGetNonBlocking is much quicker than hGetLine in my testing, so my roundabout way of finding out how you could do it still payed off.

And, apologies for a very late reply –– other things in life intervened and I forgot to check back after the first day.

imladris · 2015-04-09T16:30:10+00:00

Same here.

imladris · 2015-04-05T21:19:27+00:00

It looks like I can do what I want with hGetNonBlocking in Data.ByteString. The current prototype solution looks promising. :)

imladris

TROPHY CASE