anchor.diff:        objs |> Seq.filter (fun o ->
           let f = match op with And -> Seq.forall | Or -> Seq.exists
           conds |> f (fun (op, fld, value) -> evalCondition op (pickField fld o) value))
  +  | WindowBy(fld, size, aggs) ->
  +      let aggs = List.rev aggs
  +      objs 
  +      |> Seq.sortBy (pickField fld)
  +      |> Seq.windowed size 
  +      |> Seq.map (fun win ->
  +        aggs
  +        |> List.collect (applyWinAggregation fld win)
  +        |> Array.ofSeq )
     | GroupBy(flds, aggs) ->
         let aggs = List.rev aggs
         objs 
         |> Seq.groupBy (fun j -> List.map (fun f -> pickField f j) flds)
         |> Seq.map (fun (kvals, group) ->
           aggs 
  -        |> List.collect (applyAggregation (List.zip flds kvals) group)
  -        |> Array.ofSeq)
  +        |> List.collect (applyGroupAggregation (List.zip flds kvals) group)
  +        |> Array.ofSeq )
   
   // ----------------------------------------------------------------------------
   // Schema inference and CSV file parsing
  
positive.code:     | "filter", conds -> FilterBy(And, List.map parseCondition conds)
      | "groupby", ops ->
          let keys = ops |> List.takeWhile (fun s -> s.StartsWith "by ") |> List.map (fun s -> trimIdent (s.Substring(3)))
          let aggs = ops |> List.skipWhile (fun s -> s.StartsWith "by ") |> List.map parseAggOp
          GroupBy(keys, aggs)
      | "take", [n] -> Paging [Take (int n)]
      | "skip", [n] -> Paging [Skip (int n)]
      | _ -> failwith "Unsupported transformation"
  
negative.code:   | String s1, String s2 -> reverse * compare s1 s2
    | _ -> failwith "Cannot compare values"
  
  let evalCondition op actual (expected:string) =
    match op, actual with 
    | _, Date _ -> failwith "Comparison on dates not supported"
    | Equals, Bool b -> (expected.ToLower() = "true" && b) || (expected.ToLower() = "false" && not b)
    | NotEquals, Bool b -> (expected.ToLower() = "true" && not b) || (expected.ToLower() = "false" && b)
    | Equals, String s -> expected = s
    | NotEquals, String s -> expected <> s
    | (Equals | NotEquals), Number _ -> failwith "Equals and not equals work only on strings or booleans"
    | GreaterThan, Number n -> n > decimal expected
    | LessThan, Number n -> n < decimal expected
    | InRange, Number n -> let expected = expected.Split(',') in n > decimal expected.[0] && n < decimal expected.[1]
    | (GreaterThan | LessThan | InRange), (Bool _ | String _) -> failwith "Relational operator work only on numbers"
  
  let transformData (objs:seq<(string * Value)[]>) = function
    | Empty -> objs
  