Updated parser, CYKState model and gitignore

Author: DerYeger

.gitignore

@@ -33,14 +33,14 @@
 # When using Gradle or Maven with auto-import, you should exclude module files,
 # since they will be recreated, and may cause churn.  Uncomment if using
 # auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
+ .idea/artifacts
+ .idea/compiler.xml
+ .idea/jarRepositories.xml
+ .idea/modules.xml
+ .idea/*.iml
+ .idea/modules
+ *.iml
+ *.ipr
 
 # CMake
 cmake-build-*/

gradle.properties

@@ -5,10 +5,9 @@ kotlin.mpp.stability.nowarn=true
 dokkaVersion=1.4.10
 kotlinVersion=1.4.10
 ktlintVersion=9.4.1
-kotlinResultVersion=1.1.9
 
-libraryVersion=0.1.0
-libraryDescription=CYK
+libraryVersion=0.2.0
+libraryDescription=Kotlin Multiplatform implementation of the CYK algorithm.
 publishedGroupId=eu.yeger
 artifact=cyk-algorithm
 bintrayRepo=maven

src/commonMain/kotlin/eu/yeger/cyk/Result.kt

@@ -20,6 +20,13 @@ public fun <T : Any, U : Any> Result<T>.map(transformation: (T) -> U): Result<U>
     }
 }
 
+public fun <T : Any> Result<T>.mapError(transformation: (String) -> String): Result<T> {
+    return when (this) {
+        is Result.Success -> this
+        is Result.Failure -> fail(transformation(error))
+    }
+}
+
 public fun <T : Any, U : Any> Result<T>.andThen(transformation: (T) -> Result<U>): Result<U> {
     return when (this) {
         is Result.Success -> transformation(data)
@@ -34,6 +41,13 @@ public fun <T : Any, U : Any> Result<T>.and(other: Result<U>): Result<U> {
     }
 }
 
+public fun <T : Any> Result<T>.getOrNull(): T? {
+    return when (this) {
+        is Result.Success -> data
+        is Result.Failure -> null
+    }
+}
+
 public fun <T : Any> Result<T>.getOr(fallback: T): T {
     return when (this) {
         is Result.Success -> data
@@ -47,3 +61,24 @@ public fun <T : Any> Result<T>.getOrElse(block: (String) -> T): T {
         is Result.Failure -> block(error)
     }
 }
+
+public fun <T : Any> Result<T>.getErrorOrNull(): String? {
+    return when (this) {
+        is Result.Success -> null
+        is Result.Failure -> error
+    }
+}
+
+public fun <T : Any> Result<T>.getErrorOr(fallback: String): String {
+    return when (this) {
+        is Result.Success -> fallback
+        is Result.Failure -> error
+    }
+}
+
+public fun <T : Any> Result<T>.getErrorOrElse(block: (T) -> String): String {
+    return when (this) {
+        is Result.Success -> block(data)
+        is Result.Failure -> error
+    }
+}

src/commonMain/kotlin/eu/yeger/cyk/RunningCYK.kt

@@ -13,17 +13,19 @@ public fun runningCYK(
     word: Word,
     grammar: Grammar,
 ): List<CYKState> {
-    val cykStartState = CYKStart(CYKModel(word, grammar))
+    val cykStartState = CYKState.Start(CYKModel(word, grammar))
     return (0..word.size).fold(listOf(cykStartState)) { previousStates: List<CYKState>, l: Int ->
         when (l) {
             0 -> previousStates.runningPropagateTerminalProductionRules()
             else -> previousStates.runningPropagateNonTerminalProductionRules(l + 1)
         }
+    }.let { previousStates: List<CYKState> ->
+        previousStates + previousStates.last().terminated()
     }
 }
 
 private fun List<CYKState>.runningPropagateTerminalProductionRules(): List<CYKState> {
-    return last().cykModel.word.foldIndexed(this) { terminalSymbolIndex: Int, previousStates: List<CYKState>, terminalSymbol: TerminalSymbol ->
+    return last().model.word.foldIndexed(this) { terminalSymbolIndex: Int, previousStates: List<CYKState>, terminalSymbol: TerminalSymbol ->
         previousStates.runningFindProductionRulesForTerminalSymbol(terminalSymbol, terminalSymbolIndex)
     }
 }
@@ -32,7 +34,7 @@ private fun List<CYKState>.runningFindProductionRulesForTerminalSymbol(
     terminalSymbol: TerminalSymbol,
     terminalSymbolIndex: Int,
 ): List<CYKState> {
-    return last().cykModel.grammar.productionRuleSet.terminatingRules.fold(this) { previousStates: List<CYKState>, terminatingRule: TerminatingRule ->
+    return last().model.grammar.productionRuleSet.terminatingRules.fold(this) { previousStates: List<CYKState>, terminatingRule: TerminatingRule ->
         val lastState = previousStates.last()
         previousStates + when {
             terminatingRule produces terminalSymbol -> lastState.stepWithRuleAt(
@@ -54,7 +56,7 @@ private fun List<CYKState>.runningFindProductionRulesForTerminalSymbol(
 private fun List<CYKState>.runningPropagateNonTerminalProductionRules(
     l: Int,
 ): List<CYKState> {
-    return (1..(last().cykModel.word.size - l + 1)).fold(this) { rowSteps: List<CYKState>, s: Int ->
+    return (1..(last().model.word.size - l + 1)).fold(this) { rowSteps: List<CYKState>, s: Int ->
         (1 until l).fold(rowSteps) { columnSteps: List<CYKState>, p: Int ->
             columnSteps.runningFindProductionRulesForNonTerminalSymbols(l = l, s = s, p = p)
         }
@@ -66,10 +68,10 @@ private fun List<CYKState>.runningFindProductionRulesForNonTerminalSymbols(
     s: Int,
     p: Int,
 ): List<CYKState> {
-    return last().cykModel.grammar.productionRuleSet.nonTerminatingRules.fold(this) { previousStates: List<CYKState>, nonTerminatingRule: NonTerminatingRule ->
+    return last().model.grammar.productionRuleSet.nonTerminatingRules.fold(this) { previousStates: List<CYKState>, nonTerminatingRule: NonTerminatingRule ->
         val lastState = previousStates.last()
         previousStates + when {
-            lastState.cykModel.allowsNonTerminalRuleAt(
+            lastState.model.allowsNonTerminalRuleAt(
                 nonTerminatingRule,
                 l = l,
                 s = s,

src/commonMain/kotlin/eu/yeger/cyk/model/CYKState.kt

@@ -3,31 +3,36 @@ package eu.yeger.cyk.model
 public data class Coordinates(val row: Int, val column: Int)
 
 public sealed class CYKState {
-    public abstract val cykModel: CYKModel
-}
+    public abstract val model: CYKModel
+
+    public data class Start(
+        public override val model: CYKModel,
+    ) : CYKState()
 
-public data class CYKStart(
-    public override val cykModel: CYKModel,
-) : CYKState()
+    public data class Step(
+        public override val model: CYKModel,
+        public val productionRule: ProductionRule,
+        public val productionRuleWasApplied: Boolean,
+        public val sourceCoordinates: Coordinates,
+        public val targetCoordinates: List<Coordinates>,
+    ) : CYKState()
 
-public data class CYKStep(
-    public override val cykModel: CYKModel,
-    public val productionRule: ProductionRule,
-    public val ruleWasApplied: Boolean,
-    public val sourceCoordinates: Coordinates,
-    public val targetCoordinates: List<Coordinates>
-) : CYKState()
+    public data class Done(
+        public override val model: CYKModel,
+        public val wordIsMemberOfLanguage: Boolean,
+    ) : CYKState()
+}
 
 internal fun CYKState.stepWithRuleAt(
     productionRule: ProductionRule,
     rowIndex: Int,
     columnIndex: Int,
     targetCoordinates: List<Coordinates>,
-): CYKStep {
-    return CYKStep(
-        cykModel = cykModel.withSymbolAt(productionRule.left, rowIndex = rowIndex, columnIndex = columnIndex),
+): CYKState.Step {
+    return CYKState.Step(
+        model = model.withSymbolAt(productionRule.left, rowIndex = rowIndex, columnIndex = columnIndex),
         productionRule = productionRule,
-        ruleWasApplied = true,
+        productionRuleWasApplied = true,
         sourceCoordinates = Coordinates(rowIndex, columnIndex),
         targetCoordinates = targetCoordinates,
     )
@@ -38,12 +43,19 @@ internal fun CYKState.stepWithoutRuleAt(
     rowIndex: Int,
     columnIndex: Int,
     targetCoordinates: List<Coordinates>,
-): CYKStep {
-    return CYKStep(
-        cykModel = cykModel,
+): CYKState.Step {
+    return CYKState.Step(
+        model = model,
         productionRule = productionRule,
-        ruleWasApplied = false,
+        productionRuleWasApplied = false,
         sourceCoordinates = Coordinates(rowIndex, columnIndex),
         targetCoordinates = targetCoordinates,
     )
 }
+
+internal fun CYKState.terminated(): CYKState.Done {
+    return CYKState.Done(
+        model = model,
+        wordIsMemberOfLanguage = model.result,
+    )
+}

src/commonMain/kotlin/eu/yeger/cyk/parser/RuleParser.kt renamed to src/commonMain/kotlin/eu/yeger/cyk/parser/GrammarParser.kt

@@ -3,9 +3,12 @@ package eu.yeger.cyk.parser
 import eu.yeger.cyk.*
 import eu.yeger.cyk.model.*
 
-private val startSymbolRegex = Regex("[A-Z]+[a-z]*")
+private const val terminalSymbolRegexString = "[a-z]+"
+private const val nonTerminalSymbolRegexString = "[A-Z]+[a-z]*"
 
-private val productionRuleRegex = Regex("[A-Z]+[a-z]* -> ([A-Z]+[a-z]* [A-Z]+[a-z]*|[a-z]+)")
+public val terminalSymbolRegex: Regex = terminalSymbolRegexString.toRegex()
+public val nonTerminalSymbolRegex: Regex = nonTerminalSymbolRegexString.toRegex()
+public val productionRuleRegex: Regex = "$nonTerminalSymbolRegexString -> ($nonTerminalSymbolRegexString $nonTerminalSymbolRegexString|$terminalSymbolRegexString)".toRegex()
 
 public fun grammar(
     startSymbol: String,
@@ -15,23 +18,22 @@ public fun grammar(
     return parseAsGrammar(
         startSymbol = startSymbol,
         includeEmptyProductionRule = includeEmptyProductionRule,
-        rulesString = block(),
+        productionRules = block(),
     )
 }
 
 public fun parseAsGrammar(
     startSymbol: String,
     includeEmptyProductionRule: Boolean = false,
-    rulesString: String,
+    productionRules: String,
 ): Result<Grammar> {
     return parse(
         startSymbol = startSymbol,
         includeEmptyProductionRule = includeEmptyProductionRule,
-        rulesString = rulesString
+        productionRules = productionRules
     ).map { productionRuleSet ->
         Grammar(
             startSymbol = StartSymbol(startSymbol),
-
             productionRuleSet = productionRuleSet,
         )
     }
@@ -40,11 +42,11 @@ public fun parseAsGrammar(
 public fun parse(
     startSymbol: String,
     includeEmptyProductionRule: Boolean = false,
-    rulesString: String,
+    productionRules: String,
 ): Result<ProductionRuleSet> {
     return validateStartSymbol(startSymbol)
         .andThen { validatedStartSymbol ->
-            rulesString.trimIndent()
+            productionRules.trimIndent()
                 .lines()
                 .filter { it.isNotBlank() }
                 .parseLines(validatedStartSymbol)
@@ -59,7 +61,8 @@ public fun parse(
 
 private fun validateStartSymbol(startSymbol: String): Result<StartSymbol> {
     return when {
-        startSymbol matches startSymbolRegex -> succeed(StartSymbol(startSymbol))
+        startSymbol matches nonTerminalSymbolRegex -> succeed(StartSymbol(startSymbol))
+        startSymbol.isBlank() -> fail("Start symbol cannot be blank.")
         else -> fail("Invalid start symbol: $startSymbol")
     }
 }
@@ -93,7 +96,7 @@ private fun List<String>.asProductionRule(startSymbol: StartSymbol): Result<Prod
     return when (size) {
         3 -> asNonTerminatingProductionRule(inputSymbol)
         2 -> asTerminatingProductionRule(inputSymbol)
-        else -> fail("Invalid component amount ($size)! Must be 2 or 3")
+        else -> fail("Invalid component amount ($size)! Must be 2 for terminal or 3 for non terminal production rules.")
     }
 }
 

src/commonTest/kotlin/eu/yeger/cyk/RunningCYKTests.kt

@@ -1,6 +1,6 @@
 package eu.yeger.cyk
 
-import eu.yeger.cyk.model.result
+import eu.yeger.cyk.model.CYKState
 import eu.yeger.cyk.parser.grammar
 import kotlin.test.Test
 import kotlin.test.assertFalse
@@ -28,7 +28,7 @@ class RunningCYKTests {
                 """.trimIndent()
             }
         }.getOrElse { error(it) }
-        assertTrue(states.last().cykModel.result)
+        assertTrue((states.last() as CYKState.Done).wordIsMemberOfLanguage)
     }
 
     @Test
@@ -51,30 +51,30 @@ class RunningCYKTests {
                 """.trimIndent()
             }
         }.getOrElse { error(it) }
-        assertFalse(states.last().cykModel.result)
+        assertFalse((states.last() as CYKState.Done).wordIsMemberOfLanguage)
     }
 
     @Test
     fun verifyThatTheRunningCYKAlgorithmDetectsEmptyWords() {
         val states = runningCYK("") {
             grammar("S", includeEmptyProductionRule = true) { "" }
         }.getOrElse { error(it) }
-        assertTrue(states.last().cykModel.result)
+        assertTrue((states.last() as CYKState.Done).wordIsMemberOfLanguage)
     }
 
     @Test
     fun verifyThatTheRunningCYKAlgorithmDoesntDetectsEmptyWordsIncorrectlyExplicitly() {
         val states = runningCYK("") {
             grammar("S", includeEmptyProductionRule = false) { "" }
         }.getOrElse { error(it) }
-        assertFalse(states.last().cykModel.result)
+        assertFalse((states.last() as CYKState.Done).wordIsMemberOfLanguage)
     }
 
     @Test
     fun verifyThatTheRunningCYKAlgorithmDoesntDetectsEmptyWordsIncorrectlyImplicitly() {
         val states = runningCYK("") {
             grammar("S") { "" }
         }.getOrElse { error(it) }
-        assertFalse(states.last().cykModel.result)
+        assertFalse((states.last() as CYKState.Done).wordIsMemberOfLanguage)
     }
 }