aoc2021 VS ghc

I've done every year in Haskell (2015 2016 2017 2018 2019 2020 2021), and so have several other people such as /u/glguy. I don't see if /u/mstksg has anything published for 2015 but they've done 2016 2017 2018 2019 2020 2021 along with some pretty good writeups, I recommend checking those out.

I ran my own benchmarks for a whole ton of code at https://github.com/ephemient/aoc2021 on both Linux x64 and macos x64, and ended up disabling Kotlin/Native because it was varying between 10x and 100x slower than Kotlin/JVM, eventually timing out on CI. The generated code may be reasonable thanks to LLVM, but the runtime certainly is not.

Took a while for me to get around to completing this in Kotlin, Python, and Rust as well, since I was working on optimizing other solutions, but I finally made it.

So I switched tacks and implemented this in Kotlin, where mutation is easier. First version was brute-force with duplicate state avoidance (checked before the state explosion at every input), which worked quickly enough for part 1, but ran into OOMs for part 2. Once I replaced the HashSet with a custom LruSet (and later a simpler CacheSet which simply overwrites on hash collisions) it ran part 2 in a few minutes. I then ported this into Haskell.

Haskell 1171/339

Kotlin, Python, and Rust solutions are the same solution but much uglier.

I'm doing the same cached recursion in Kotlin, Python, and Rust.

Haskell 621/603

Haskell 258/240

Haskell Kotlin 622/1185

of course it does! what else would you call something like chicken scheme [https://call-cc.org/], ats [https://ats-lang.sourceforge.net/], or ghc [https://www.haskell.org/ghc/]? they are not "scripts", they are full-blown compilers that happen to use C as their compilation target, and then leverage C compilers to generate code for a variety of architecures. it's a very sensible way to do things.

Agree about Haskell... as far as I'm aware there is actually no declarative/easily-readable definition of the Haskell syntax that is also complete, especially when it comes to the indentation rules, and the syntax is basically defined by the very (ironically) imperatively-defined GHC parser[0].

I prefer a syntax like in Pure[1], where the ambiguous, hard to parse indentation-based syntax is replaced by explicit semicolons (Yeah, you can use braces/semicolons in Haskell as well, but most code doesn't).

[0] https://github.com/ghc/ghc/blob/master/compiler/GHC/Parser/L...

[1] https://agraef.github.io/pure-lang/

GHC, the main Haskell compiler

GHCi, version 9.6.3: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /Users/daniel/.ghci ghci> :{ | split :: Float -> [Int] | split value = map(read . (:[])) . show | :} :3:15: error: [GHC-83865] • Couldn't match expected type: [Int] with actual type: a0 -> [b0] • Probable cause: ‘(.)’ is applied to too few arguments In the expression: map (read . (: [])) . show In an equation for ‘split’: split value = map (read . (: [])) . show

GHC is hosted on Gitlab, the Github repo is just a mirror. So money.

https://github.com/ghc/ghc

☁ ~ ghci GHCi, version 9.4.7: https://www.haskell.org/ghc/ :? for help ghci> 6 + 3^2 * 4 42

Depending on who you ask, a programming language can be different things. If you ask the Haskell community, many will tell you that the language is the Haskell specification, and that what currently is being used is not Haskell itself, but an extension of Haskell that is supported by the GHC compiler. Similar to the C language, a programming language would be a specification.

GHCi, version 9.4.2: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from ~/.dotfiles/ghc/.ghc/ghci.conf