tricu

An interpreted language for exploring Tree Calculus
Log | Files | Refs | README | LICENSE

df06fabda353c5d88c0463e63f3d260c584abf0258ff2e3b9ca500481f4e0658.tri (5080B)

      1 !import prelude *
      2 !import parser *
      3 !import source_order *
      4 !import source_compile *
      5 !import source_program *
      6 !import source_resolve *
      7 !import source_ast *
      8 !import source_stable *
      9 !export *
     10 
     11 -- Build definition bindings in stable dependency order, including unused
     12 -- definitions. The reducer may defer normalization of unused body trees.
     13 -- Extend the association list at the head in O(1); resolution sees local
     14 -- definitions before supplied external bindings.
     15 sourceCompileDefinition environment definition = (lazyResult
     16   (diagnostic remainder : err diagnostic remainder)
     17   (core unused : sourceCompileCore core)
     18   (resolveGateAst environment (sourceDefinitionBody definition)))
     19 
     20 sourceCompileOrderedWith compileDefinition names definitions external = (let rec
     21   walk pending compiled = (lazyList
     22     (_ : ok compiled t)
     23     (name rest : lazyMaybe
     24       (_ : err (parserDiagnostic 33 name t t t) name)
     25       (definition : lazyResult
     26         (diagnostic remainder : err diagnostic remainder)
     27         (tree unused : walk rest (pair (pair name tree) compiled))
     28         (compileDefinition (append compiled external) definition))
     29       (sourceFindDefinition definitions name)) pending)
     30   in walk names t)
     31 sourceCompileOrdered names definitions external =
     32   sourceCompileOrderedWith sourceCompileDefinition names definitions external
     33 
     34 -- Explicit selection: a local `main` wins, otherwise the final expression,
     35 -- otherwise a missing-root diagnostic. Definitions are ordered first.
     36 sourceSelectProgram external program compiled =
     37   lazyMaybe
     38     (_ : lazyMaybe
     39       (_ : err (parserDiagnostic 32 "main" t t t) t)
     40       (expression :
     41         lazyResult
     42           (diagnostic remainder : err diagnostic remainder)
     43           (core unused : sourceCompileCore core)
     44           (resolveGateAst (append compiled external) expression))
     45       (sourceProgramFinal program))
     46     (tree : ok tree t)
     47     (sourceFindExternal compiled "main")
     48 
     49 -- The reusable single-unit boundary also returns compiled definitions in
     50 -- stable dependency order. Values remain raw trees, not compiler-private ASTs.
     51 compileGateProgramOutput external characters =
     52   parserMatchReply
     53     (diagnostic remainder consumed committed : err diagnostic remainder)
     54     (program remainder consumed committed : (do stableBind
     55       ordered <- orderGateProgram external program
     56       compiled <- sourceCompileOrdered ordered (sourceProgramDefinitions program) external
     57       root <- sourceSelectProgram external program compiled
     58       ok (pair root (reverse compiled)) t))
     59     (parseGateProgram characters)
     60 
     61 -- Public single-unit boundary. Keep the environment explicit: it contains
     62 -- already-resolved (name, tree) bindings, not paths or import directives.
     63 -- The selected root and dependency-ordered definitions are returned together;
     64 -- parsing, ordering and compilation failures retain their structured replies.
     65 compileSource environment sourceCharacters =
     66   compileGateProgramOutput environment sourceCharacters
     67 
     68 -- Module units have explicit exports, not an implicit `main` or final value.
     69 -- This entrypoint shares the ordinary parser, orderer, resolver and reference
     70 -- backend, but rejects a final expression instead of requiring a root.
     71 sourceModuleCheckShadows imports definitions = (let rec
     72   walk remaining = (lazyList
     73     (_ : ok t t)
     74     (binding rest : lazyMaybe
     75       (_ : walk rest)
     76       (definition : err
     77         (parserDiagnostic 46 (fst binding) (fst binding)
     78           (sourceDefinitionPosition definition) t) t)
     79       (sourceFindDefinition definitions (fst binding))) remaining)
     80   in walk imports)
     81 
     82 compileModuleDefinitionsWith orderProgram compileDefinition environment characters =
     83   parserMatchReply
     84     (diagnostic remainder consumed committed : err diagnostic remainder)
     85     (program remainder consumed committed :
     86       lazyMaybe
     87         (_ : (do stableBind
     88           sourceModuleCheckShadows environment (sourceProgramDefinitions program)
     89           ordered <- orderProgram environment program
     90           compiled <- sourceCompileOrderedWith compileDefinition ordered
     91             (sourceProgramDefinitions program) environment
     92           ok (reverse compiled) t))
     93         (expression : err
     94           (parserDiagnostic 42 "definitions only" t
     95             (sourceAstStart expression) t) expression)
     96         (sourceProgramFinal program))
     97     (parseGateProgram characters)
     98 
     99 -- Backend selection is explicit. Existing entrypoints retain optimized trees.
    100 compileModuleDefinitions environment characters =
    101   compileModuleDefinitionsWith orderGateProgram sourceCompileDefinition environment characters
    102 compileStableModuleDefinitions environment characters =
    103   compileModuleDefinitionsWith orderStableProgram sourceCompileStableDefinition environment characters
    104 
    105 -- Preserve the established gate API: callers interested only in the root
    106 -- do not have to inspect (or force) the compiled definition environment.
    107 compileGateProgram external characters =
    108   lazyResult
    109     (diagnostic remainder : err diagnostic remainder)
    110     (output unused : ok (fst output) t)
    111     (compileGateProgramOutput external characters)
    112