anchor.diff:  
   [<Test>]
   let testPositionToMoves () =
  -  let trainingModule = "training_programs"
  -  let methods = compiler.getMethodsOfModule trainingModule
     let exp1 = 
       <@ 
         fun a -> 
  
positive.code: type ProgramMoves = SubExpr<Move list>
  
  type ProgramExternalState = 
    (* Set of Applicable Rules *)
    RuleInfo Set * 
    (* Current Depth *)
    int 
  
negative.code:           move :: (rcr exp childPos)
    rcr e zeroMetaData
  
  let positionToSubexpr (e: Expr) (pos: RulePosition): Expr =
    let rec rcr (exp: Expr) (rootPos: RulePosition): Expr = 
      if rootPos = pos then
        exp
      else
        match exp with 
        | ExprShape.ShapeLambda(i, e) -> rcr e (rootPos + 1)
        | ExprShape.ShapeVar(v)       -> failwithf "shouldn't reach to var %A" exp
        | Patterns.Value(v, tp)       -> failwithf "shouldn't reach to value %A" exp
        | ExprShape.ShapeCombination(o, exprs) ->
            let exprsPos = ([rootPos + 1], exprs) ||> List.fold (fun list cur -> (List.head list) + exprSize cur :: list) |> List.rev
            let idx = exprsPos |> List.findIndex (fun p -> p > pos)
            let childPos = List.nth exprsPos (idx - 1)
            let exp = List.nth exprs (idx - 1)
            rcr exp childPos
    rcr e zeroMetaData
  
  let subexpr ((e, pos) as state: ProgramState): Expr = 
    positionToSubexpr e pos
  
  let stateToMoves ((e, pos) as state: ProgramState): ProgramMoves = 
    e, positionToMoves e pos
  
  let stateToExternal (rs: Rule list) (state: ProgramState) : ProgramExternalState = 
    let rules = examineAllRulesPositioned rs (subexpr state) |> List.filter (fun r -> (fst r) = 0) |> List.map (fun i -> snd (snd i)) |> Set.ofList
    let currentDepth = snd (stateToMoves state) |> List.length
    rules, currentDepth
  
  