About TRH example

[folivetti]

I've been thinking about the TRH example from Notion.

I think the simplest way a human programmer without implement that would be with two folds and a "window" function between them. So, let's suppose that we have a timeseries organized as:

struct TS {
    int index;  // the timestamp
    int data[N]; // each element of this array is one drug
};

patient = TS[M];  // M timestamps measured for this particular patient (it is the transpose of your draft of data representation)

int [] getCasesOfInterest( TS patient, int [] acc) {
    int tot = sum(patient.data);
    if (tot > 4) {
        insertAt(acc, 0 , patient.index); // insert the index in the beggining of the accumulator
   }
  return acc;
}

int countCases(Pair<int, int> p, int acc) {
    if (p.second - p.first > 1) {  // more than a month apart
          return acc + 1;
   return acc
}

response = fold_right( window(2, 
                                             fold_right(patient, empty, getCasesOfInterest)),
                                         0, countCases);

This is just a draft of a c++ code, and I'm assuming there is a function window that generates a moving window view of a list, so, window(2, [1,2,3,4]) = [(1,2), (2,3), (3,4)] .

So, in short, for this particular example we just need the fold_right and window function, assuming Brush will evolve the functions passed as parameters to the folds.
Of course in our grammar we could have the different flavors of fold (Map, Filter, ...) and then we would have something like:

Length(Filter(p2.index - p1.index > 1, Window(2, Filter(p.data > 4, Map(sum, patient)))))

There is actually one way to do this procedure using a single pass (without having the window function). I'll look into that to see if the solution would make things easier or not.

[folivetti]

ok, I made a prototype of the single-fold solution for this expression. I have used something called "histomorphism" that, in short, is a fold in which the accumulator is a trace of every step of the folding. Let's say we have in our grammar a FoldWithTrace that implements this histomorphism, this function only requires the starting value of the accumulator (as we want to count, it is $0$) and a function of a tuple of (index, data) and the history of the trace of the fold.

For this specific model, the function would be

def f( (index, data), history ):
    if sum(data)  > 3:
        if history[0].index > -1 and history[0].index - index > 4:
            return (index, history[0].data + 1)  # here, history[0].data is the accumulator of the fold, starting with 0
        else:
            return (index, history[0].data)
    else:
           return history[0]

the (badly scribbled) tree would be:

(this could be simplified with a better domain specific language)

I think for this purpose we can either go with supporting frequently used higher-order functions, such as map, filter, etc. and simply compose them. Or the foldWithTrace, which gives additional freedom to how Brush creates the models.

@lacava do you have more examples for me to play with? 😄