Implementing a JIT Compiled Language with Haskell and LLVM

Implementing a JIT Compiled Language with Haskell and LLVM(stephendiehl.com)

81 points by niels 12 years ago | 12 comments

lallysingh 12 years ago |

Even if you're not curious about Haskell, have a look at the parser here. Parsing in Haskell feels like cheating.

tel 12 years ago | |

(And is a really great example motivating both monads and monad transformers, for the curious!)

tel 12 years ago | | |

For the extra curious, here's a little Parser (untested, poor design, but generally the right idea)

    newtype Parser a = Parser { unParser :: MaybeT (State String) a }
      deriving ( Functor, Applicative, Alternative, 
                 Monad, MonadPlus, MonadTrans, 
                 MonadState String )
        -- why write boilerplate when the 
        -- compiler will for you?

    runParser :: Parser a -> String -> Maybe a
    runParser input = flip evalStateT input . runMaybeT 

    -- | Parses a single character if it passes a predicate
    satisfy :: (Char -> Bool) -> Parser Char
    satisfy p = do
      (c:cs) <- get
      guard (p c)
      put cs
      return c
 
    char :: Char -> Parser Char
    char c = satisfy (== c)

    -- | Parses a whole string
    string :: String -> Parser String
    string = mapM char

    -- | Converts a parser to be surrounded by parentheses
    parens :: Parser a -> Parser a
    parens p = char '(' *> p <* char ')'

freyrs3 12 years ago | | |

The shallow DSL in the LLVM monad is really nice, it looks almost like the IR itself but you can abstract over it and compose it with other code. DSLs are often overlooked when talking about monad use cases.

casion 12 years ago | |

If you're not curious about haskell, I suspect that parser is going to be very difficult to grok.

At least a basic understanding of haskell (or similar) is going to be required to appreciate it, and at that point you're obviously someone who was curious enough to have the knowledge to understand it to begin with.

batterseapower 12 years ago |

A while ago I wrote a Haskell compiler for a simple functional language that uses the JIT features of LLVM in order to make the Haskell-level "compile" function lazy in the term being compiled. Quite a fun trick I thought: https://github.com/batterseapower/productive-compiler/blob/m...

taspeotis 12 years ago |

Good job with that trailing /

    Implementing a JIT Compiled Language with Haskell and LLVM (stephendiehl.com)
    195 points by rwosync 53 days ago | flag | comments

https://news.ycombinator.com/item?id=7031998

thirsteh 12 years ago | |

Let's not make this like reddit where there's scores of people who have nothing to do but complain about something they've already seen.

If it's interesting, it's interesting. If it's not worthy of being seen again, it won't be upvoted. By all means link to the previous discussion, but quit the whining.

taspeotis 12 years ago | | |

Reddit hasn't been intentionally coded to avoid duplicate submissions.

jevinskie 12 years ago | |

There are other users that kindly point out prior submissions to highlight past discussions. You're just being unpleasant.

arms 12 years ago | |

As someone who's interested in Haskell and missed this the first time around, I'm glad it's back.

newtype Parser a = Parser { unParser :: MaybeT (State String) a } deriving ( Functor, Applicative, Alternative, Monad, MonadPlus, MonadTrans, MonadState String ) -- why write boilerplate when the -- compiler will for you? runParser :: Parser a -> String -> Maybe a runParser input = flip evalStateT input . runMaybeT -- | Parses a single character if it passes a predicate satisfy :: (Char -> Bool) -> Parser Char satisfy p = do (c:cs) <- get guard (p c) put cs return c char :: Char -> Parser Char char c = satisfy (== c) -- | Parses a whole string string :: String -> Parser String string = mapM char -- | Converts a parser to be surrounded by parentheses parens :: Parser a -> Parser a parens p = char '(' *> p <* char ')'