shake

Neither of those sound like you have actually understood the feature. The point of Tup's partial DAG is that it starts from the file changes and only loads relevant dependency information for those files (and its transitive closure). So for example if you have 1 million .c files and one of them is changed, say a.c, then it does 3 lookups: "what depends on a.c?" (a.o), "what depends on a.o?" (the .exe), "what depends on the .exe?" (nothing, it is a target). So dependency chasing is minimal and it takes very little time until the commands for a.o and the .exe are loaded and rerun. In contrast, in your approach, you will still have to go through the million files - maybe Rig won't require an OS 'stat' call and can just check the watcher's list in-memory for each file, but it will still burn a significant number of cycles following dependency

Yes! More "real-world" Haskell is always good. This seems like a good time to bring up Shake, Neil Mitchell's build system: http://shakebuild.com/ It can be used like CMake (as a build script generator) or like Ninja. For many projects (including building Ninja), it's faster than Ninja. Chromium is a notable exception: it has a huge set of Ninja files, and the Shake parser is not as fast as Ninja's parser. From the docs: > [...] compiling LLVM on Windows under mingw they both take the same time to compile initially, and Ninja takes 0.9s for a nothing to do build vs Shake at 0.8s. Shake is slower at parsing Ninja files, so if you have huge .ninja files (e.g. Chromium) Shake will probably be slower. Shake does less work if you don't specify deps, which is probably why it is faster on LLVM (but you should specify deps -- it makes both Shake

> there was never a situation when I said to myself "if only Data.HashMap (unordered-containers) was faster" Here's a Haskell programmer looking for a faster hashmap: https://github.com/ndmitchell/shake/issues/418 Shake in fact does use reified generics (a.k.a. Dynamic/Typeable) and a Value type, and recommends disabling idle GC. I'm not sure if there's a "GC write barrier", Shake just uses MVar locks.

The Manual[0] contains an intro that isn't particularly compelling. It contains things like: phony "clean" $ do putNormal "Cleaning files in _build" removeFilesAfter "_build" ["//*"] Which would be the make equivalent: clean: rm _build/* Now that's obviously the trivial example. But its not trivial to drop make entirely for something entirely different. A make solution can slowly get more complicated over time. It looks like shake might be useful for something really big. I can't quite tell where the investment of learning a new tool and re-develop something(that works well enough) would pay off. 0: https://github.com/ndmitchell/shake/blob/master/docs/Manual....

I've always wondered why Shake[0] wasn't more popular. Anyone not like Shake or know why others don't, or is this just a case of not being known? 0: https://github.com/ndmitchell/shake

When you did that, did you use Shake[^1] for the build scripts? If not, check it out! It lets you easily say things like "bundle.tar.gz depends on the file MANIFEST and on every file mentioned in it", for example. [^1]: https://github.com/ndmitchell/shake

https://github.com/ndmitchell/shake Shake is an awesome alternative to Make written in Haskell. It fixes a lot of the weird dependency tracking issues Make has ("my build broke and I don't know why!" "did you make clean?")