diff --git a/codego/aussagenlogik/rekursion/rekursion.go b/codego/aussagenlogik/rekursion/rekursion.go
index 90710af..a06735d 100644
--- a/codego/aussagenlogik/rekursion/rekursion.go
+++ b/codego/aussagenlogik/rekursion/rekursion.go
@@ -1,7 +1,6 @@
 package rekursion
 
 import (
-	"log"
 	"logik/aussagenlogik/syntaxbaum"
 	"logik/core/utils"
 )
@@ -10,72 +9,62 @@ import (
  * EXPORTS
  * ---------------------------------------------------------------- */
 
-func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int {
-	var children = tree.GetChildren()
+type RekursiveChannelInt struct {
+	channel chan int
+}
+
+func RekursivEval(ch chan int, tree syntaxbaum.SyntaxBaum, I []string) {
+	// Werte für Teilformeln rekursiv berechnen
+	fn := func(_ch chan int, _tree syntaxbaum.SyntaxBaum) { RekursivEval(_ch, _tree, I) }
+	var values = RekursiveCallInt(fn, tree.GetChildren())
+	// Aus Werten für Teilformeln Wert für Formeln berechnen
 	if tree.IsAtom() || tree.IsGeneric() {
-		if utils.StrListContains(I, tree.Expr) {
-			return 1
-		}
-		return 0
+		ch <- utils.BoolToInt(utils.StrListContains(I, tree.GetExpr()))
 	} else if tree.IsTautologySymbol() {
-		return 1
+		ch <- 1
 	} else if tree.IsContradictionSymbol() {
-		return 0
+		ch <- 0
 	} else if tree.IsNegation() {
-		subtree0, _ := tree.GetChild()
-		val0 := RekursivEval(subtree0, I)
-		return 1 - val0
+		ch <- 1 - values[0]
 	} else if tree.IsConjunction2() {
-		val0 := RekursivEval(children[0], I)
-		val1 := RekursivEval(children[1], I)
-		return utils.Min2(val0, val1)
+		ch <- utils.Min2(values[0], values[1])
 	} else if tree.IsConjunction() {
-		var val = 1
-		for _, subtree := range children {
-			var val_ = RekursivEval(subtree, I)
-			val = utils.Min2(val, val_)
-		}
-		return val
+		ch <- utils.MinList(values)
 	} else if tree.IsDisjunction2() {
-		val0 := RekursivEval(children[0], I)
-		val1 := RekursivEval(children[1], I)
-		return utils.Max2(val0, val1)
+		ch <- utils.Max2(values[0], values[1])
 	} else if tree.IsDisjunction() {
-		var val = 0
-		for _, subtree := range children {
-			var val_ = RekursivEval(subtree, I)
-			val = utils.Max2(val, val_)
-		}
-		return val
+		ch <- utils.MaxList(values)
 	} else if tree.IsImplication() {
-		val0 := RekursivEval(children[0], I)
-		val1 := RekursivEval(children[1], I)
-		if val0 <= val1 {
-			return 1
-		}
-		return 0
+		ch <- utils.BoolToInt(values[0] <= values[1])
 	} else {
-		log.Fatal("Could not evaluate expression!")
-		return 0
+		panic("Could not evaluate expression!")
 	}
 }
 
-func RekursivAtoms(tree syntaxbaum.SyntaxBaum) []string {
+func RekursivAtoms(ch chan []string, tree syntaxbaum.SyntaxBaum) {
+	// // Werte für Teilformeln rekursiv berechnen
+	// var values = RekursiveCallStringList(RekursivAtoms, tree.GetChildren())
 	// Herausforderung: schreibe diese Funktion!
-	return []string{}
+	ch <- []string{}
 }
 
-func RekursivDepth(tree syntaxbaum.SyntaxBaum) int {
+func RekursivDepth(ch chan int, tree syntaxbaum.SyntaxBaum) {
+	// // Werte für Teilformeln rekursiv berechnen
+	// var values = RekursiveCallInt(RekursivDepth, tree.GetChildren())
 	// Herausforderung: schreibe diese Funktion!
-	return 0
+	ch <- 0
 }
 
-func RekursivLength(tree syntaxbaum.SyntaxBaum) int {
+func RekursivLength(ch chan int, tree syntaxbaum.SyntaxBaum) {
+	// // Werte für Teilformeln rekursiv berechnen
+	// var values = RekursiveCallInt(RekursivLength, tree.GetChildren())
 	// Herausforderung: schreibe diese Funktion!
-	return 0
+	ch <- 0
 }
 
-func RekursivParentheses(tree syntaxbaum.SyntaxBaum) int {
+func RekursivParentheses(ch chan int, tree syntaxbaum.SyntaxBaum) {
+	// // Werte für Teilformeln rekursiv berechnen
+	// var values = RekursiveCallInt(RekursivParentheses, tree.GetChildren())
 	// Herausforderung: schreibe diese Funktion!
-	return 0
+	ch <- 0
 }