Moin Leute,
ich versuch mich mal wieder in ein bisschen Gehacke.. ich wollte mir mal etwas die funktionalen Sprachen untersuchen. Dazu hab ich mal Scala angeschaut.. und das kam für einen Lexer normaler Terme raus:
|
C#-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
object Lexer {
def isNumber(c: Char): Boolean = {
if ((c >= '0' && c <= '9') || c == '.') true else false
}
def isNumber(str: List[Char]): Boolean = str match {
case Nil => true
case x :: xs => if (isNumber(x)) isNumber(xs) else false
}
def lexString(s: String): List[String] = {
def lex(stringToLex: List[Char]): (List[String], String) = stringToLex match {
case Nil => (List(""), null) // not possible
case x :: Nil => (List(), x.toString())
case x :: xs => {
val (lstLexedExpressions, bufferedExpression) = lex(xs)
if (isNumber(bufferedExpression.toList))
if (isNumber(x)) (lstLexedExpressions, x + bufferedExpression)
else
(bufferedExpression.toString :: lstLexedExpressions, x.toString())
// x is an expression
else (bufferedExpression.toString :: lstLexedExpressions, x.toString())
}
}
lex(s.toList)._2.toString :: lex(s.toList)._1
}
}
|
an all die Funktionalen Programmierprofis, geht das noch schöne, sprich, sind hier die funktionalen konstrukte einigermaßen optimal genutzt worden oder ist das mehr oder weniger dirty java code? außerdem ich frage mich, ob dieses Tuple hier wirklich notwendig ist, oder ob es auch anders ginge