56 lines
1.6 KiB
Org Mode
56 lines
1.6 KiB
Org Mode
* Introduction
|
|
Write a static analyzer for ruby.
|
|
|
|
Used an existing parser for ruby called `ruby-parse`.
|
|
|
|
`ruby-parse` can generate an AST in JSON format.
|
|
|
|
This made the task of writing a ruby parser simpler: Haskell comes
|
|
with a great JSON parser. So we just have to specify how to convert
|
|
from the AST defined by `ruby-parse` to our own AST.
|
|
|
|
* Implementation
|
|
** ADTs
|
|
*** Purpose
|
|
Defining an Abstract Syntax Tree (AST) for Ruby using Algebraic Data
|
|
Types (ADTs).
|
|
|
|
*** Example
|
|
-- Value represents any JSON data (object, string, number, null, array)
|
|
Args = Value
|
|
Name = Value
|
|
Block = [Definition]
|
|
Definition = Module | Function | Send
|
|
Namespace = [Name]
|
|
Send = {args : Args, namespace : Namespace, name :: Name}
|
|
Module = {name : Name, block : Block}
|
|
Function = {name : Name, args : Args, block :: Block}
|
|
|
|
*** Live coding
|
|
|
|
Define `Function`
|
|
** Higher-order types
|
|
Missing a good example here.
|
|
|
|
** Type classes
|
|
*** Purpose
|
|
Be able to concert unstructured JSON data into our ADT.
|
|
|
|
*** Example
|
|
Consider the class
|
|
|
|
class FromJSON a where
|
|
parseJSON :: Value -> Parser a
|
|
|
|
It's saying that `a` is convertible from json if there is a function
|
|
`parseJSON` that takes a (json) `Value` and returns a `Parser a`.
|
|
`Parser a` can be thought of as a procedure for generating a value of
|
|
type `a`.
|
|
|
|
So for instance. The monomorphic type `Parser Function` is a
|
|
procedure that generates a value of type `Function`:
|
|
*** Live coding
|
|
Define an instance for `FromJSON` for `Function`.
|
|
|
|
Define an instance for `FromJSON` for `Definition`.
|