Based on Lennart's code, I implemented ADT and GADT versions of simply-typed lambda calculus with de Bruijn indices, integer constants, and addition, plus the conversion between them, without the distraction of compiling to LLVM. The code was cleaned and improved by Shayan Najd, and made publicly available via github. Thanks to Josef Svenningson for the pointer to Lennart's post.
I want to test a library with multiple GHC configurations but don't have the resources to run many VMs at once. I'd like to have an arbitrary number of independent installations on each of the 3 big platforms. This way, I could test against multiple versions of the Haskell platform, the most recent versions of libraries, development versions of Haskell, etc. to ensure everything works. Are there any resources on this?
Thanks in advance.submitted by MechaBlue
[link] [4 comments]
In an attempt to solidify and extend my knowledge of category theory, I have been working my way through the excellent series of category theory lectures posted on Youtube by Eugenia Cheng and Simon Willerton, aka the Catsters.
Edsko de Vries used to have a listing of the videos, but it is no longer available. After wresting a copy from a Google cache, I began working my way through the videos, but soon discovered that Edsko’s list was organized by subject, not topologically sorted. So I started making my own list, and have put it up here in the hopes that it may be useful to others. Suggestions, corrections, improvements, etc. are of course welcome!
As far as possible, I have tried to arrange the order so that each video only depends on concepts from earlier ones. Along with each video you can also find my cryptic notes; I make no guarantee that they will be useful to anyone (even me!), but hopefully they will at least give you an idea of what is in each video.
I have a goal to watch two videos per week (at which rate it will take me about nine months to watch all of them); I will keep the list updated with new video links and notes as I go.
Last semester in school, I took a compiler construction class, and wrote a compiler for a small imperative language in Python. I've been meaning to try and write a compiler for an OO language, and also to do a larger project in Haskell. I thus decided to implement Alex Aiken's COOL language (see Coursera for more information) in Haskell.
So far, I have my lexer, parser and pretty printer and they work well. I'm now at the semantics analysis phase, but I'm not sure what would be a good way to implement a symbol table in Haskell. By that I mean, I'm not sure where the table should reside. Should it be a value that's computed once by a function and passed around to every other function that needs it? Should I put symbol information in the attribute field of my AST nodes?
If anyone has suggestions and/or reading material recommendations, I'd be very grateful.
gnuvincesubmitted by gnuvince
[link] [9 comments]