XfrpOpBody = object
  args: seq[WithCodeInfo[XfrpIdAndType]]
  retType: WithCodeInfo[XfrpType]
  body: WithCodeInfo[XfrpExpr]

XfrpOpDescription = object
  symbol: XfrpOperator
  precedence: XfrpInfixPrecedence
  body: TableRef[seq[XfrpType], XfrpOpBody]

XfrpOpId = tuple[moduleId: XfrpModuleId, op: XfrpOperator]

XfrpOpEnv = distinct TableRef[XfrpOpId, XfrpOpDescription]

proc reparseBinaryExpression(opEnv: XfrpOpEnv; exp: WithCodeInfo[XfrpExpr];
                             definedIn: XfrpModuleId; materialTbl: XfrpMaterials): WithCodeInfo[
    XfrpExpr] {...}{.raises: [KeyError, XfrpDefinitionError, XfrpSyntaxError],
                tags: [].}

proc makeOperatorEnvironment(materialTbl: XfrpMaterials): XfrpOpEnv {...}{.
    raises: [KeyError, XfrpDefinitionError, XfrpReferenceError], tags: [].}

proc getOperator(opEnv: XfrpOpEnv; id: XfrpOpId): XfrpOpDescription {...}{.
    raises: [KeyError], tags: [].}

proc findOpId(opEnv: XfrpOpEnv; op: XfrpOperator; termTypes: seq[XfrpType];
              definedIn: XfrpModuleId; materialTbl: XfrpMaterials): XfrpOpId {...}{.
    raises: [KeyError, XfrpLanguageError], tags: [].}

proc symbol(desc: XfrpOpDescription): XfrpOperator {...}{.raises: [], tags: [].}

proc getBody(desc: XfrpOpDescription; argTypes: seq[XfrpType]): XfrpOpBody {...}{.
    raises: [KeyError], tags: [].}

proc args(opBody: XfrpOpBody): seq[WithCodeInfo[XfrpIdAndType]] {...}{.raises: [],
    tags: [].}

proc retType(opBody: XfrpOpBody): WithCodeInfo[XfrpType] {...}{.raises: [], tags: [].}

proc body(opBody: XfrpOpBody): WithCodeInfo[XfrpExpr] {...}{.raises: [], tags: [].}

iterator items(opEnv: XfrpOpEnv): XfrpOpId {...}{.raises: [], tags: [].}

iterator availableArgTypes(desc: XfrpOpDescription): seq[XfrpType] {...}{.raises: [],
    tags: [].}