core: removed symbol table, use epackage instead, adapted resolvers

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/Evaluator.kt

@@ -1,22 +1,23 @@
 package ch.kleis.lcaac.core.lang.evaluator
 
-import ch.kleis.lcaac.core.lang.SymbolTable
-import ch.kleis.lcaac.core.lang.evaluator.protocol.Oracle
 import ch.kleis.lcaac.core.lang.evaluator.protocol.Learner
+import ch.kleis.lcaac.core.lang.evaluator.protocol.Oracle
 import ch.kleis.lcaac.core.lang.expression.*
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 import org.slf4j.LoggerFactory
 
 class Evaluator<Q>(
-    private val symbolTable: SymbolTable<Q>,
+    private val pkg: EPackage<Q>,
+    private val pkgResolver: PkgResolver<Q>,
     private val ops: QuantityOperations<Q>,
 ) {
     @Suppress("PrivatePropertyName")
     private val LOG = LoggerFactory.getLogger(Evaluator::class.java)
 
     fun trace(initialRequests: Set<EProductSpec<Q>>): EvaluationTrace<Q> {
         val learner = Learner(initialRequests, ops)
-        val oracle = Oracle(symbolTable, ops)
+        val oracle = Oracle(pkg, pkgResolver, ops)
         LOG.info("Start evaluation")
         try {
             var requests = learner.start()

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/ToValue.kt

@@ -11,6 +11,18 @@ class ToValue<Q>(
         return with(ops) { q().toDouble() }
     }
 
+    private fun PackageExpression<Q>.toValue(): PackageValue<Q> {
+        return when(this) {
+            is EPackage -> PackageValue(
+                this.name,
+                this.params.data.mapValues { it.value.toValue() }.mapKeys { it.key.name },
+                this.with.mapValues { it.value.toValue() },
+            )
+            is EImport -> TODO("Should throw appropriate exception")
+            is EImportRef -> TODO("Should throw appropriate exception")
+        }
+    }
+
     fun EProcess<Q>.toValue(): ProcessValue<Q> {
         return ProcessValue(
             this.name,
@@ -22,7 +34,7 @@ class ToValue<Q>(
         )
     }
 
-    fun DataExpression<Q>.toValue(): DataValue<Q> {
+    private fun DataExpression<Q>.toValue(): DataValue<Q> {
         return when (this) {
             is EStringLiteral -> StringValue(this.value)
 
@@ -60,7 +72,7 @@ class ToValue<Q>(
         )
     }
 
-    fun EProductSpec<Q>.toValue(): ProductValue<Q> {
+    private fun EProductSpec<Q>.toValue(): ProductValue<Q> {
         val name = this.name
         @Suppress("UNCHECKED_CAST")
         val referenceUnitValue = (this.referenceUnit as QuantityExpression<Q>?)
@@ -93,19 +105,20 @@ class ToValue<Q>(
             else -> throw EvaluatorException("$this is not reduced")
         }
 
-    fun ESubstanceSpec<Q>.toValue(): SubstanceValue<Q> {
+    private fun ESubstanceSpec<Q>.toValue(): SubstanceValue<Q> {
         @Suppress("UNCHECKED_CAST")
         val referenceUnit = (this.referenceUnit as QuantityExpression<Q>?)
             ?.toUnitValue()
             ?: throw EvaluatorException("$this has no reference unit")
-        val type = this.type ?: return PartiallyQualifiedSubstanceValue(this.name, referenceUnit)
-        val compartment = this.compartment ?: return PartiallyQualifiedSubstanceValue(this.name, referenceUnit)
+        val type = this.type ?: return PartiallyQualifiedSubstanceValue(this.name, referenceUnit, this.pkg!!.toValue())
+        val compartment = this.compartment ?: return PartiallyQualifiedSubstanceValue(this.name, referenceUnit, this.pkg!!.toValue())
         return FullyQualifiedSubstanceValue(
             this.name,
             type,
             compartment,
             this.subCompartment,
             referenceUnit,
+            this.pkg?.toValue() ?: PackageValue.default(),
         )
     }
 
@@ -139,6 +152,7 @@ class ToValue<Q>(
                     is EDataRef -> throw EvaluatorException("$it is not reduced")
                 }
             },
+            this.pkg?.toValue() ?: PackageValue.default(),
         )
     }
 

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/protocol/Oracle.kt

@@ -1,24 +1,26 @@
 package ch.kleis.lcaac.core.lang.evaluator.protocol
 
-import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.step.CompleteTerminals
 import ch.kleis.lcaac.core.lang.evaluator.step.Reduce
 import ch.kleis.lcaac.core.lang.evaluator.step.ReduceLabelSelectors
+import ch.kleis.lcaac.core.lang.expression.EPackage
 import ch.kleis.lcaac.core.lang.expression.EProcess
 import ch.kleis.lcaac.core.lang.expression.EProcessTemplateApplication
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.lang.resolver.ProcessResolver
 import ch.kleis.lcaac.core.lang.resolver.SubstanceCharacterizationResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class Oracle<Q>(
-    val symbolTable: SymbolTable<Q>,
+    pkg: EPackage<Q>,
+    pkgResolver: PkgResolver<Q>,
     val ops: QuantityOperations<Q>,
 ) {
-    private val reduceLabelSelectors = ReduceLabelSelectors(symbolTable, ops)
-    private val reduceDataExpressions = Reduce(symbolTable, ops)
+    private val reduceLabelSelectors = ReduceLabelSelectors(pkg, pkgResolver, ops)
+    private val reduceDataExpressions = Reduce(pkg, pkgResolver, ops)
     private val completeTerminals = CompleteTerminals(ops)
-    private val processResolver = ProcessResolver(symbolTable)
-    private val substanceCharacterizationResolver = SubstanceCharacterizationResolver(symbolTable)
+    private val processResolver = ProcessResolver(pkg, pkgResolver)
+    private val substanceCharacterizationResolver = SubstanceCharacterizationResolver(pkg, pkgResolver)
 
     fun answer(ports: Set<Request<Q>>): Set<Response<Q>> {
         return ports.mapNotNull { answerRequest(it) }.toSet()

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/DataExpressionReducer.kt

@@ -1,18 +1,19 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
-import ch.kleis.lcaac.core.lang.register.DataKey
-import ch.kleis.lcaac.core.lang.register.DataRegister
 import ch.kleis.lcaac.core.lang.dimension.UnitSymbol
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.expression.*
+import ch.kleis.lcaac.core.lang.resolver.DataResolver
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 import kotlin.math.pow
 
 class DataExpressionReducer<Q>(
-    dataRegister: DataRegister<Q>,
+    private val pkg: EPackage<Q>,
+    private val pkgResolver: PkgResolver<Q>,
     private val ops: QuantityOperations<Q>,
+    private val dataResolver: DataResolver<Q> = DataResolver(pkg, pkgResolver),
 ) {
-    private val dataRegister = DataRegister(dataRegister)
     private val infiniteUnitLoopChecker = InfiniteUnitLoopChecker<Q>()
 
     fun reduce(expression: DataExpression<Q>): DataExpression<Q> {
@@ -68,7 +69,7 @@ class DataExpressionReducer<Q>(
     }
 
     private fun reduceClosure(closure: EQuantityClosure<Q>): DataExpression<Q> =
-        DataExpressionReducer(closure.pkg.data, ops).reduce(closure.expression)
+        DataExpressionReducer(closure.pkg, pkgResolver, ops).reduce(closure.expression)
 
     private fun reduceDiv(expression: EQuantityDiv<Q>): DataExpression<Q> {
         with(ops) {
@@ -132,9 +133,9 @@ class DataExpressionReducer<Q>(
         }
     }
 
+    // TODO: Verify me
     private fun reduceRef(expression: EDataRef<Q>): DataExpression<Q> {
-        val key = DataKey(expression.name)
-        return dataRegister[key]?.let { reduce(it) } ?: expression
+        return dataResolver.resolve(expression)?.let { reduce(it) } ?: expression
     }
 
     private fun reduceScale(expression: EQuantityScale<Q>): DataExpression<Q> {

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/LcaExpressionReducer.kt

@@ -1,15 +1,15 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
-import ch.kleis.lcaac.core.lang.register.DataRegister
 import ch.kleis.lcaac.core.lang.expression.*
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class LcaExpressionReducer<Q>(
-    dataRegister: DataRegister<Q> = DataRegister.empty(),
+    pkg: EPackage<Q>,
+    pkgResolver: PkgResolver<Q>,
     ops: QuantityOperations<Q>,
+    private val dataExpressionReducer: DataExpressionReducer<Q> = DataExpressionReducer(pkg, pkgResolver, ops),
 ) {
-    private val dataExpressionReducer = DataExpressionReducer(dataRegister, ops)
-
     fun reduce(expression: LcaExpression<Q>): LcaExpression<Q> {
         return when (expression) {
             is EProcess -> reduceProcess(expression)

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/TemplateExpressionReducer.kt

@@ -1,19 +1,19 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
 import arrow.optics.Every
-import ch.kleis.lcaac.core.lang.register.DataKey
-import ch.kleis.lcaac.core.lang.register.DataRegister
-import ch.kleis.lcaac.core.lang.register.Register
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.evaluator.Helper
 import ch.kleis.lcaac.core.lang.expression.*
+import ch.kleis.lcaac.core.lang.register.DataKey
+import ch.kleis.lcaac.core.lang.register.DataRegister
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class TemplateExpressionReducer<Q>(
+    private val pkg: EPackage<Q>,
+    private val pkgResolver: PkgResolver<Q>,
     private val ops: QuantityOperations<Q>,
-    dataRegister: DataRegister<Q> = DataRegister.empty(),
 ) {
-    private val dataRegister = Register(dataRegister)
     private val helper = Helper<Q>()
 
     fun reduce(expression: EProcessTemplateApplication<Q>): EProcess<Q> {
@@ -28,12 +28,15 @@ class TemplateExpressionReducer<Q>(
         val actualArguments = template.params
             .plus(expression.arguments)
 
-        val localRegister = DataRegister(dataRegister)
+        val locals = DataRegister(pkg.data)
             .plus(actualArguments.mapKeys { DataKey(it.key) })
             .plus(template.locals.mapKeys { DataKey(it.key) })
+        val localPkg = pkg.copy(
+            data = locals
+        )
 
-        val reducer = LcaExpressionReducer(localRegister, ops)
-        val dataReducer = DataExpressionReducer(localRegister, ops)
+        val reducer = LcaExpressionReducer(localPkg, pkgResolver, ops)
+        val dataReducer = DataExpressionReducer(localPkg, pkgResolver, ops)
 
         var result = template.body
         actualArguments.forEach {

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/step/Reduce.kt

@@ -1,27 +1,23 @@
 package ch.kleis.lcaac.core.lang.evaluator.step
 
-import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.evaluator.Helper
 import ch.kleis.lcaac.core.lang.evaluator.reducer.LcaExpressionReducer
 import ch.kleis.lcaac.core.lang.evaluator.reducer.TemplateExpressionReducer
+import ch.kleis.lcaac.core.lang.expression.EPackage
 import ch.kleis.lcaac.core.lang.expression.EProcess
 import ch.kleis.lcaac.core.lang.expression.EProcessTemplateApplication
 import ch.kleis.lcaac.core.lang.expression.ESubstanceCharacterization
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class Reduce<Q>(
-    symbolTable: SymbolTable<Q>,
+    pkg: EPackage<Q>,
+    pkgResolver: PkgResolver<Q>,
     ops: QuantityOperations<Q>,
 ) {
-    private val lcaReducer = LcaExpressionReducer(
-        symbolTable.data,
-        ops
-    )
-    private val templateReducer = TemplateExpressionReducer(
-        ops,
-        symbolTable.data,
-    )
+    private val lcaReducer = LcaExpressionReducer(pkg, pkgResolver, ops)
+    private val templateReducer = TemplateExpressionReducer(pkg, pkgResolver, ops)
 
     fun apply(expression: EProcessTemplateApplication<Q>): EProcess<Q> {
         val reduced = templateReducer.reduce(expression)

core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/step/ReduceLabelSelectors.kt

@@ -1,16 +1,17 @@
 package ch.kleis.lcaac.core.lang.evaluator.step
 
 import arrow.optics.Every
-import ch.kleis.lcaac.core.lang.register.DataKey
-import ch.kleis.lcaac.core.lang.register.Register
-import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.reducer.DataExpressionReducer
 import ch.kleis.lcaac.core.lang.expression.*
 import ch.kleis.lcaac.core.lang.expression.optics.everyDataRefInDataExpression
+import ch.kleis.lcaac.core.lang.register.DataKey
+import ch.kleis.lcaac.core.lang.register.Register
+import ch.kleis.lcaac.core.lang.resolver.PkgResolver
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class ReduceLabelSelectors<Q>(
-    private val symbolTable: SymbolTable<Q>,
+    private val pkg: EPackage<Q>,
+    private val pkgResolver: PkgResolver<Q>,
     private val ops: QuantityOperations<Q>,
 ) {
     private val everyInputProduct =
@@ -27,13 +28,13 @@ class ReduceLabelSelectors<Q>(
         val labels = template.body.labels
         val actualArguments = template.params.plus(expression.arguments)
         val locals = template.locals
-        val reducer = DataExpressionReducer(
-            Register(symbolTable.data)
+        val localPkg = pkg.copy(
+            data = Register(pkg.data)
                 .plus(actualArguments.mapKeys { DataKey(it.key) })
                 .plus(labels.mapKeys { DataKey(it.key) })
                 .plus(locals.mapKeys { DataKey(it.key) }),
-            ops,
         )
+        val reducer = DataExpressionReducer(localPkg, pkgResolver, ops)
         return everyLabelSelector.modify(expression) { ref -> reducer.reduce(ref) }
     }
 }