XfrpId = string

XfrpModuleId = string

XfrpIdAndType = tuple[id: WithCodeInfo[XfrpId], ty: WithCodeInfo[XfrpType]]

XfrpIdAndTypeOptKind {...}{.pure.} = enum
  IdWithExplicitType, IdWithoutAnyTypeAnnot

XfrpIdAndTypeOpt = object
  case kind*: XfrpIdAndTypeOptKind
  of XfrpIdAndTypeOptKind.IdWithExplicitType:
      idExplicit*: WithCodeInfo[XfrpId]
      tyExplicit*: WithCodeInfo[XfrpType]

  of XfrpIdAndTypeOptKind.IdWithoutAnyTypeAnnot:
      idImplicit*: WithCodeInfo[XfrpId]

  

XfrpAnnotationKind {...}{.pure.} = enum
  AnnotAtLast

XfrpAnnotation = object
  case kind*: XfrpAnnotationKind
  of XfrpAnnotationKind.AnnotAtLast:
      nil

  

XfrpLiteralKind {...}{.pure.} = enum
  LitBool, LitInt, LitFloat

XfrpLiteral = object
  case kind*: XfrpLiteralKind
  of XfrpLiteralKind.LitBool:
      boolVal*: bool

  of XfrpLiteralKind.LitInt:
      intVal*: int

  of XfrpLiteralKind.LitFloat:
      floatVal*: float

  

XfrpOperator = string

XfrpOperatorPrecedenceLevel = Natural

XfrpOperatorAssociativity = enum
  assocLeft, assocRight, assocNone

XfrpExprKind {...}{.pure.} = enum
  ExprLiteral, ExprId, ExprAnnot, ExprBin, ExprIf, ExprApp, ExprMagic

XfrpExpr = object
  case kind*: XfrpExprKind
  of XfrpExprKind.ExprLiteral:
      litVal*: WithCodeInfo[XfrpLiteral]

  of XfrpExprKind.ExprId:
      id*: WithCodeInfo[XfrpId]

  of XfrpExprKind.ExprAnnot:
      annotId*: WithCodeInfo[XfrpId]
      annot*: WithCodeInfo[XfrpAnnotation]

  of XfrpExprKind.ExprBin:
      binOps*: seq[WithCodeInfo[XfrpOperator]]
      binTerms*: seq[WithCodeInfo[XfrpExpr]]

  of XfrpExprKind.ExprIf:
      ifExpr*: ref WithCodeInfo[XfrpExpr]
      thenExpr*: ref WithCodeInfo[XfrpExpr]
      elseExpr*: ref WithCodeInfo[XfrpExpr]

  of XfrpExprKind.ExprApp:
      appId*: WithCodeInfo[XfrpId]
      appArgs*: seq[WithCodeInfo[XfrpExpr]]

  of XfrpExprKind.ExprMagic:
      magicIdAndType*: WithCodeInfo[XfrpIdAndType]
      magicArgs*: seq[WithCodeInfo[XfrpExpr]]

  

XfrpDefinitionKind {...}{.pure.} = enum
  DefNode, DefFunc, DefOp, DefInfix, DefInit

XfrpDefinition = object
  case kind*: XfrpDefinitionKind
  of XfrpDefinitionKind.DefNode:
      nodeIdAndTypeOpt*: WithCodeInfo[XfrpIdAndTypeOpt]
      nodeInit*: Option[WithCodeInfo[XfrpExpr]]
      nodeBody*: WithCodeInfo[XfrpExpr]

  of XfrpDefinitionKind.DefFunc:
      funId*: WithCodeInfo[XfrpId]
      funRetType*: WithCodeInfo[XfrpType]
      funArgs*: seq[WithCodeInfo[XfrpIdAndType]]
      funBody*: WithCodeInfo[XfrpExpr]

  of XfrpDefinitionKind.DefOp:
      operator*: WithCodeInfo[XfrpOperator]
      opRetType*: WithCodeInfo[XfrpType]
      opArgs*: seq[WithCodeInfo[XfrpIdAndType]]
      opBody*: WithCodeInfo[XfrpExpr]

  of XfrpDefinitionKind.DefInfix:
      infixOp*: WithCodeInfo[XfrpOperator]
      infixLevel*: XfrpOperatorPrecedenceLevel
      infixAssoc*: XfrpOperatorAssociativity

  of XfrpDefinitionKind.DefInit:
      initId*: WithCodeInfo[XfrpId]
      initBody*: WithCodeInfo[XfrpExpr]

  

XfrpInputKind {...}{.pure.} = enum
  InputWithoutInit, InputWithInit

XfrpInput = object
  case kind*: XfrpInputKind
  of XfrpInputKind.InputWithoutInit:
      idAndTypeNoInit*: WithCodeInfo[XfrpIdAndType]

  of XfrpInputKind.InputWithInit:
      idAndTypeWithInit*: WithCodeInfo[XfrpIdAndType]
      init*: WithCodeInfo[XfrpExpr]

  

XfrpEmit = tuple[target, body: string]

XfrpModuleKind = enum
  modModule, modMaterial

XfrpModule = tuple[kind: XfrpModuleKind, moduleId: WithCodeInfo[XfrpModuleId],
                   ins: seq[WithCodeInfo[XfrpInput]],
                   outs: seq[WithCodeInfo[XfrpIdAndTypeOpt]],
                   uses: seq[WithCodeInfo[XfrpModuleId]],
                   emits: seq[WithCodeInfo[XfrpEmit]],
                   defs: seq[WithCodeInfo[XfrpDefinition]]]

proc `==`(a: XfrpIdAndTypeOpt; b: XfrpIdAndTypeOpt): bool {...}{.used, raises: [],
    tags: [].}

proc IdWithExplicitType(idExplicit: WithCodeInfo[XfrpId];
                        tyExplicit: WithCodeInfo[XfrpType]): XfrpIdAndTypeOpt {...}{.
    used, raises: [], tags: [].}

proc IdWithoutAnyTypeAnnot(idImplicit: WithCodeInfo[XfrpId]): XfrpIdAndTypeOpt {...}{.
    used, raises: [], tags: [].}

proc `==`(a: XfrpAnnotation; b: XfrpAnnotation): bool {...}{.used, raises: [],
    tags: [].}

proc AnnotAtLast(): XfrpAnnotation {...}{.used, raises: [], tags: [].}

proc `==`(a: XfrpLiteral; b: XfrpLiteral): bool {...}{.used, raises: [], tags: [].}

proc LitBool(boolVal: bool): XfrpLiteral {...}{.used, raises: [], tags: [].}

proc LitInt(intVal: int): XfrpLiteral {...}{.used, raises: [], tags: [].}

proc LitFloat(floatVal: float): XfrpLiteral {...}{.used, raises: [], tags: [].}

proc `==`(a: XfrpExpr; b: XfrpExpr): bool {...}{.used, raises: [], tags: [].}

proc ExprLiteral(litVal: WithCodeInfo[XfrpLiteral]): XfrpExpr {...}{.used,
    raises: [], tags: [].}

proc ExprId(id: WithCodeInfo[XfrpId]): XfrpExpr {...}{.used, raises: [], tags: [].}

proc ExprAnnot(annotId: WithCodeInfo[XfrpId];
               annot: WithCodeInfo[XfrpAnnotation]): XfrpExpr {...}{.used,
    raises: [], tags: [].}

proc ExprBin(binOps: seq[WithCodeInfo[XfrpOperator]];
             binTerms: seq[WithCodeInfo[XfrpExpr]]): XfrpExpr {...}{.used,
    raises: [], tags: [].}

proc ExprIf(ifExpr: ref WithCodeInfo[XfrpExpr];
            thenExpr: ref WithCodeInfo[XfrpExpr];
            elseExpr: ref WithCodeInfo[XfrpExpr]): XfrpExpr {...}{.used, raises: [],
    tags: [].}

proc ExprApp(appId: WithCodeInfo[XfrpId]; appArgs: seq[WithCodeInfo[XfrpExpr]]): XfrpExpr {...}{.
    used, raises: [], tags: [].}

proc ExprMagic(magicIdAndType: WithCodeInfo[XfrpIdAndType];
               magicArgs: seq[WithCodeInfo[XfrpExpr]]): XfrpExpr {...}{.used,
    raises: [], tags: [].}

proc `==`(a: XfrpDefinition; b: XfrpDefinition): bool {...}{.used, raises: [],
    tags: [].}

proc DefNode(nodeIdAndTypeOpt: WithCodeInfo[XfrpIdAndTypeOpt];
             nodeInit: Option[WithCodeInfo[XfrpExpr]];
             nodeBody: WithCodeInfo[XfrpExpr]): XfrpDefinition {...}{.used,
    raises: [], tags: [].}

proc DefFunc(funId: WithCodeInfo[XfrpId]; funRetType: WithCodeInfo[XfrpType];
             funArgs: seq[WithCodeInfo[XfrpIdAndType]];
             funBody: WithCodeInfo[XfrpExpr]): XfrpDefinition {...}{.used,
    raises: [], tags: [].}

proc DefOp(operator: WithCodeInfo[XfrpOperator];
           opRetType: WithCodeInfo[XfrpType];
           opArgs: seq[WithCodeInfo[XfrpIdAndType]];
           opBody: WithCodeInfo[XfrpExpr]): XfrpDefinition {...}{.used, raises: [],
    tags: [].}

proc DefInfix(infixOp: WithCodeInfo[XfrpOperator];
              infixLevel: XfrpOperatorPrecedenceLevel;
              infixAssoc: XfrpOperatorAssociativity): XfrpDefinition {...}{.used,
    raises: [], tags: [].}

proc DefInit(initId: WithCodeInfo[XfrpId]; initBody: WithCodeInfo[XfrpExpr]): XfrpDefinition {...}{.
    used, raises: [], tags: [].}

proc `==`(a: XfrpInput; b: XfrpInput): bool {...}{.used, raises: [], tags: [].}

proc InputWithoutInit(idAndTypeNoInit: WithCodeInfo[XfrpIdAndType]): XfrpInput {...}{.
    used, raises: [], tags: [].}

proc InputWithInit(idAndTypeWithInit: WithCodeInfo[XfrpIdAndType];
                   init: WithCodeInfo[XfrpExpr]): XfrpInput {...}{.used, raises: [],
    tags: [].}

proc makeXfrpModule(moduleId: WithCodeInfo[XfrpModuleId];
                    ins: seq[WithCodeInfo[XfrpInput]];
                    outs: seq[WithCodeInfo[XfrpIdAndTypeOpt]];
                    uses: seq[WithCodeInfo[XfrpModuleId]] = @[];
                    emits: seq[WithCodeInfo[XfrpEmit]] = @[];
                    defs: seq[WithCodeInfo[XfrpDefinition]]): XfrpModule {...}{.
    raises: [], tags: [].}

proc makeXfrpMaterial(moduleId: WithCodeInfo[XfrpModuleId];
                      uses: seq[WithCodeInfo[XfrpModuleId]] = @[];
                      emits: seq[WithCodeInfo[XfrpEmit]] = @[];
                      defs: seq[WithCodeInfo[XfrpDefinition]]): XfrpModule {...}{.
    raises: [], tags: [].}

proc split(idAndTypeOpt: XfrpIdAndTypeOpt): tuple[id: WithCodeInfo[XfrpId],
    typeOpt: Option[WithCodeInfo[XfrpType]]] {...}{.raises: [], tags: [].}

proc split(input: XfrpInput): tuple[id: WithCodeInfo[XfrpId],
                                    ty: WithCodeInfo[XfrpType],
                                    initOpt: Option[WithCodeInfo[XfrpExpr]]] {...}{.
    raises: [], tags: [].}