replace real with double.
replace Real with Double.

srecord noeq MPM2(real[] ticker) {
  // how much percentual slippage we have for each position on
  // average dependent on the market (trading site) we are using
  record Market(real adversity) {}
  
  record Juicer(real lossTolerance, real pullback) {}

  record Position(real openingTime, real direction) {
    real openingPrice() { ret ticker(openingTime); }
  }
  
  record noeq LiveTicker(real[] data, int time) {
    Real currently() { ret lookback(0); }
    Real lookback(real time) {
      int index = iceil(this.time-1-time);
      ret index >= 0 ? data[index] : null;
    }
  }

  record Eye(real time, real minMove) {
    Real adviseDirection(LiveTicker ticker) {
      Real currently = ticker.currently();
      if (currently == null) null;
      Real before = ticker.lookback(time);
      if (before == null) null;
      real move = currently-before;
      if (abs(move) >= minMove) ret (real) sign(move);
      null;
    }
  }

  real ticker(real time) { ret ticker(iceil(time)); }

  // all "profit" functions return a positive or negative percent value
  real profit(Position p, real time, Market m) {
    ret (ticker(time)/p.openingPrice()*100-100)*p.direction - m.adversity;
  }

  Real closingTime(Position p, Juicer j, Market m) {
    int time = iceil(p.openingTime);
    real openingPrice = ticker(time);
    real crest = -infinity();
    while (time < ticker.length-1) {
      real profit = profit(p, time, m);
      crest = max(crest, profit);
      if (profit < (profit < 0 ? -j.lossTolerance : crest-j.pullback)) break;
      ++time;
    }
    null;
  }

  Real profit(Position p, Juicer j, Market m) {
    Real closingTime = closingTime(p, j, m);
    ret closingTime == null ? null : profit(p, closingTime, m);
  }

  // How profitable is it to open a position of any direction
  // at a certain point in time?
  Real profitability(real time, Juicer j, Market m) {
    ret maxAllowingNull(
      profit(new Position(time, -1), j, m), 
      profit(new Position(time,  1), j, m));
  }
  
  abstract class Convergent extends ItIt<Real> {
    Real value;
    bool stepped, done;
    
    public bool hasNext() {
      if (done) false;
      
      if (!stepped) {
        stepped = true;
        step();
      }
      
      ret !done;
    }
    
    public Real next() {
      assertTrue(hasNext());
      stepped = false;
      ret value;
    }
    
    abstract void step();
  }
  
  record noeq JuicerBacktest(Juicer j, Market m) extends Convergent {
    // TODO: use randomized "weightless" shuffling iterator
    Iterator<Int> openingTimes = shuffledIterator(intRangeList(ticker.length));
    new Average profitPerPosition;
    
    // percentage of positions closed before reaching the end of the ticker "tape"
    new Average positionsClosedInTime;
    
    void step {
      if (!openingTimes.hasNext())
        ret with done = true;
        
      real openingTime = openingTimes.next();
      Real profit = profitability(openingTime, j, m);
      positionsClosedInTime.addSample(profit != null ? 100 : 0);
      if (profit != null)
        profitPerPosition.addSample(profit);
      value = profitPerPosition!;
    }
  }
}