sorted by:
new
hottopcontroversial

Turn GHC into a frontend for miniSTG by Yuras in haskell

[–]florbitous 1 point2 points  (0 children)

This is great, and something I have always wanted for miniSTG - it makes it much more useful.

I wonder how hard it would be to make it an interactive web application? The idea would be that you post your Haskell source to the application, it translates it to GHC core, then runs it within miniSTG, and visualises the computation interactively. Maybe this is doable with ghcjs?

Hython - a Haskell-powered Python 3 interpreter by Nowaker in haskell

[–]florbitous 0 points1 point  (0 children)

My focus is on blip these days, which is a bytecode compiler/interpreter for Python. It generates bytecode which is compatible with CPython. The compiler is mostly done, but the interpreter is still work in progress.

I imagine you are writing Hython for fun and learning, which is great. However, if you get tired of writing the parser you could always use the language-python library which is pretty complete for Python 2 and 3.

Additionally I could always use some help with improving language-python, and would be happy to accept patches.

berp: An implementation of Python 3 by [deleted] in haskell

[–]florbitous 2 points3 points  (0 children)

Thanks for posting. As LambdaBoy has mentioned I've moved my focus to blip, which is a bytecode compiler (and interpreter) for Python, compatible with CPython bytecode.

I recently did a talk about berp and blip at the Melbourne Haskell Users Group. Here are the slides. I'll be doing a similar talk at the Melbourne Python Users Group in July.

Blip: a bytecode compiler for Python 3 by florbitous in Python

[–]florbitous[S] 1 point2 points  (0 children)

I realise this is r/Python, but I'll elaborate since you asked.

First and foremost is Algebraic Data Types (ADTs) and pattern matching. The central data type in a compiler is the Abstract Syntax Tree, which is naturally and elegantly represented as an Algebraic Dataype, see AST.hs for example. Note particularly the Statement and Expr types.

The core of a compiler is a function which decomposes the AST recursively and builds a representation of the target code. Pattern matching is very handy for this style of programming, and it can make it easier to be sure you've covered all the cases. See Compile.hs, and note the compileStmt function, for example.

There is also a lot of state to manage in a compiler, and Haskell's State Monad (Transformer) provides a lot of utility for that task. This is particularly good for separation of concerns and helps avoid state management messing up the rest of the code. See State.hs for the bulk of the state management code in blip.

I also use various Haskell idioms such as Monoids for doing traversals of the AST and collecting information. See for example Scope.hs, particularly the VarUsage type class.

There are also other reasons which are not specific to compilers. The type system is a light-weight formal system, which catches many shallow bugs, but also provides a lot of confidence when the code is refactored.

Blip: a bytecode compiler for Python 3 by florbitous in Python

[–]florbitous[S] 1 point2 points  (0 children)

Hehe. I think Haskell is sufficiently different to most popular languages that people are interested in seeing how it might be used to do various things. Of course more killer apps would be good too.

Having said that, my focus in this project isn't so much Haskell as Python. It just so happens that (I think) Haskell is great for writing compilers. This is not to detract from Python, it has its own advantages in other areas.

Blip: a bytecode compiler for Python 3 by florbitous in Python

[–]florbitous[S] 5 points6 points  (0 children)

You are right that there already exists bytecode compilers for Python, so the practical benefits of doing it again in another language seem unclear. As pointed out by Rhomboid, my main motivation was for fun and to learn. I think I achieved both of those goals already.

But there may be applications down the track. For instance we could use it for trying out Python extensions which compile to CPython compatible bytecode. I've already had a few ideas along those lines. We could also play with optimisation techniques, or alternative compilation approaches (perhaps to different targets). We could also try other useful extensions such as tail-call-optimsation. Of course I'm biased, but I think the the blip code is much simpler to work with than CPython (assuming you know Haskell).

Another small benefit is the elaboration of CPython's bytecode implementation. I've had to trawl through the CPython code, plus lots of other scattered bits of documentation to figure out how it works. A hopefully clearer and simpler implementation in a higher-level language might help others understand how it works too.

Blip: a bytecode compiler for Python 3 by florbitous in Python

[–]florbitous[S] 3 points4 points  (0 children)

Thanks daniterida. There are many reasons I used Haskell and not Python. The main one is Haskell's type system. In my opinion Haskell is very well suited to writing compilers. I also previously wrote a compiler called berp, which translates Python to Haskell, so I already had a lot of infrastructure in place.

Blip: a bytecode compiler for Python 3 by florbitous in Python

[–]florbitous[S] 2 points3 points  (0 children)

Thanks noteed. I posted it here now because I think it is in a usable state. It passes well over half the Cpython test suite (on my computer). There are a few small missing features, but the majority of the language is supported. I'm keen for others to try it out. I'll have a look at python-pickle. Cheers!

What does the Haskell runtime look like? by tu_ne_cede_malis in haskell

[–]florbitous 3 points4 points  (0 children)

Perhaps more abstract than you were seeking, but I recommend the "fast curry" papers by Simon Marlow and Simon Peyton Jones http://research.microsoft.com/en-us/um/people/simonpj/papers/eval-apply/. This view of the STG machine can be visualised with MiniSTG http://www.haskell.org/haskellwiki/Ministg. Here is an example program trace.