Run the parser on toplas98 benchmark programs.

Now we have a large language parser but missing a few syntax features (or sugars) like lists, string literals etc.

Core language:

• Core language parser - @yuxuanchen1997
• Core language concrete interpreters (small-step, refunc., big-step) - @Kraks
• Core language abstract interpreters (AAM, ADI, path/flow/context-sensitive, store-widening, abstract domains) - @Kraks
• Core language staged abstract interpreters

Large language:

• Benchmarks
• Large language parser - @yuxuanchen1997
• Large language concrete interpreters - @yuxuanchen1997
• Large language abstract interpreters (small-step and big-step, as baselines)
• Large language staged abstract interpreters

For comparisons (on the benchmarks):

• Small-step AAM with abstract compilation (ICFP13)
• Fully optimized AAM (ICFP13)
• ADI with abstract compilation

https://dl.acm.org/citation.cfm?doid=2500365.2500604

Study section 5.4 Abstract Compilation. Do comparison.

First commit here.

Basic idea is to use rvalue ref std::move(*this) as a replacement for returning new objects, so that it can (in the future) work with the current user code in the form of SS x123 = x234.some_act(...

Revisions on major data structures are done, but interfaces are still incompatible with some user code, especially when they assumed the use of immer.

Hello Wei,

I just read your OOPSLA paper and looked at your code. First off, great work!

In particular, I looked at the fixpoint algorithm (https://github.com/Kraks/sai/blob/master/dev-clean/src/main/scala/sai/interpreters/Abstract.scala#L144-L170). I believe you stop the fixpoint iteration too early. You have to keep iterating until the fixpoint cache stabilizes:

def run(e: Expr): Result = {
  var newCache = cache0
  do {
    // the start of a new fixpoint iteration

    // oldCache refers to the cache of the previous iteration
    var oldCache = newCache

    // newCache refers to the cache of the current iteration.
    newCache = cache0

    newCache = fix(eval)(e)(ρ0)(σ0).run(oldCache)(newCache).run.getOutCache()
  } while (oldCache < newCache); // check if a fixpoint has been reached
}

This part of the fixpoint algorithm is described in the ADI paper in Figure 8.

You should be able to see the difference by analyzing a program that does not reach its fixpoint in one iteration, e.g., diverge n = if n < 0 then 1 else diverge (n) + 1. When you analyze the interval of diverge, with the current version of the algorithm the result should be diverge([-∞,∞]) = [1,1] ⊔ ⟂ = [1,1], with my proposal the analysis result should be diverge([-∞,∞]) = [1,∞].

Let me know what you think.

Hello,

It would be great if you could provide Docker images for the tools contained in this repo so uses can try them out easily.

@yuxuanchen1997 , the changes break some unit tests, e.g.,

assert("1".read[Var] == None)