功能Scala的重构/布局

Question

这个班轮......

 Console.println(io.Source.fromFile("names.txt").getLines.mkString.split(",").map{x:String => x.slice(1, x.length -1)}.sortBy { x => x}.zipWithIndex.map{t =>{ (t._2 +1)*(t._1.map{_.toChar - "A"(0).toChar + 1}.sum)}}.sum);

...是我对Project Euler问题22的解决方案。 它似乎工作，它写在（我的尝试）功能风格。

这个例子有点极端，但我的问题更为笼统 - 您更喜欢编写/格式化/评论功能样式代码？ 功能方法似乎鼓励了一系列方法调用，我发现这些方法调用不可读，而且放置注释也无处可寻。

此外，当我编写过程代码时，我发现我编写了一些小方法，每个方法都有一个目的和有意义的名称。 当我编写功能代码时，我似乎正在养成一种习惯，这种习惯产生的线条与上面的一样，其中（对我而言）意义难以破译 - 而且个别计算也难以在其他地方重复使用。 我在网上看到的很多功能代码示例同样简洁（对我而言）模糊不清。

我该怎么办？ 为当前上下文中有意义的名称编写计算的每个部分的小函数？ （即使它们只是地图的包装，说？）

对于我给出的例子，有什么更好的方法来编写它并呈现它？

（就像所有风格的问题一样，这个问题是主观的。但是没有理由它应该引起争议！）

Answer 1

一个简单的第一次尝试来整理它就是删除领先的Console. 尾随; 和explicit :String类型 - 所有这些都是不必要的 - 添加一些缩进并导入io.Source：

import io.Source
println(
  Source.fromFile("names.txt").getLines.mkString.split(",").map{
    x => x.slice(1, x.length -1)
  }.sortBy {x => x}.zipWithIndex.map{
    t =>{ (t._2 +1)*(t._1.map{_.toChar - "A"(0).toChar + 1}.sum)}
  }.sum
)

下一步是清理一下，在映射元组列表和identity而不是x=>x时使用模式匹配。 toChar对于字符也是不必要的，单引号可用于表示字符文字。

import io.Source
println(
  Source.fromFile("names.txt").getLines.mkString.split(",").map {
    x => x.slice(1, x.length -1)
  }.sortBy(identity).zipWithIndex.map {
    case (v, idx) =>{ (idx+1)*(v.map{_ - 'A' + 1}.sum)}
  }.sum
)

还有一些更改也有助于使代码的意图更加清晰：

import io.Source
println(
  Source.fromFile("names.txt").getLines.mkString.split(",")
  .map { _.stripPrefix("\"").stripSuffix("\"") }
  .sortBy(identity)
  .map { _.map{_ - 'A' + 1}.sum }
  .zipWithIndex
  .map { case (v, idx) => (idx+1) * v }
  .sum
)

下一步，使其更具“功能性”，是将其分解为“功能”（ 偷偷摸摸，是吧？ ）。 理想情况下，每个函数都会有一个清楚地表达其目的的名称，并且它将很短（旨在使其成为单个表达式，因此不需要括号）：

import io.Source

def unquote(s:String) = s.stripPrefix("\"").stripSuffix("\"")

def wordsFrom(fname:String) =
  Source.fromFile(fname).getLines.mkString.split(",").map(unquote)

def letterPos(c:Char) = c - 'A' + 1

println(
  wordsFrom("names.txt")
  .sortBy(identity)
  .map { _.map(letterPos).sum }
  .zipWithIndex
  .map { case (v, idx) => (idx+1) * v }
  .sum
)

wordsFrom是一个明显的1-liner，但我把它分开以便在stackOverflow上更容易格式化

Answer 2

以下是我认为可能更好的解决方法：

Console.println(
    io.Source.fromFile("names.txt")
    .getLines.mkString.split(",")
    .map{x:String => x.slice(1, x.length -1)}
    .sortBy { x => x}
    .zipWithIndex
    .map{t =>{ (t._2 +1)*(t._1.map{_.toChar - "A"(0).toChar + 1}.sum)}}
    .sum); 

我觉得我的大脑深处有一些算法可以决定水平和垂直空间之间的代码布局权衡，但我似乎没有直接的访问权限让我能够清楚地表达它。 :)

关于引入名称而不是使用lambdas，我认为我通常做的是，如果我想提出一个描述代码意图的简短评论，但是一个好的标识符名称也可以这样做，那么我可能会考虑一次性将lambda转换为命名函数以获得标识符名称的可读性好处。 带有toChar调用的行是上面唯一一个看起来像我的候选者。 （要清楚，我会将lambda中的一部分（部分） map到map ，但是map调用自身。）或者，垂直空白的引入为您提供了一个挂起//comment的地方，这是引入标识符名称。

（免责声明：我不写Scala，所以如果我说与样式约定冲突，那么请忽略我:)，但我想这很多建议主要与语言无关。）

Answer 3

严格说明如何格式化代码，而不进行任何结构更改，我会这样做：

Console println (
  (
    io.Source
    fromFile "names.txt"
    getLines ()
    mkString ""
    split ","
    map (x => x.slice(1, x.length - 1))
    sortBy (x => x)
    zipWithIndex
  )
  map (t => (t._2 + 1) * (t._1 map (_.toChar - "A"(0).toChar + 1) sum) )
  sum
)

或者，或许，为了解决无参数方法，我会这样做：

Console println (
  io.Source
  .fromFile("names.txt")
  .getLines
  .mkString
  .split(",")
  .map(x => x.slice(1, x.length - 1))
  .sortBy(x => x)
  .zipWithIndex
  .map(t => (t._2 + 1) * (t._1 map (_.toChar - "A"(0).toChar + 1) sum) )
  .sum
)

请注意，有足够的空间进行评论，但一般而言，正在做的事情通常很清楚。 不习惯它的人有时会在中途迷路，没有变量来跟踪转换值的含义/类型。

现在，我做的一些不同的事情是：

println ( // instead of Console println
  Source // put import elsewhere
  .fromFile("names.txt")
  .mkString // Unless you want to get rid of /n, which is unnecessary here
  .split(",")
  .map(x => x.slice(1, x.length - 1))
  .sorted // instead of sortBy
  .zipWithIndex
  .map { // use { only for multiple statements and, as in this case, pattern matching
    case (c, index) => (index + 1) * (c map (_ - 'A' + 1) sum) // chars are chars
  }
  .sum
)

我也不会在同一步骤中进行求和，所以：

  .sorted
  .map(_ map (_ - 'A' + 1) sum)
  .zipWithIndex
  .map { case (av, index) => av * (index + 1) }
  .sum

最后，我不太喜欢字符串调整大小，所以我可能会使用正则表达式。 添加一点重构，这是我可能会写的：

  import scala.io.Source
  def names = Source fromFile "names.txt" mkString

  def wordExtractor = """"(.*?)"""".r
  def words = for {
    m <- wordExtractor findAllIn names matchData
  } yield m group 1

  def alphabeticValue(s: String) = s map (_ - 'A' + 1) sum
  def wordsAV = words.toList.sorted map alphabeticValue

  def multByIndex(t: (Int, Int)) = t match {
    case (av, index) => av * (index + 1)
  }
  def wordsAVByIndex = wordsAV.zipWithIndex map multByIndex

  println(wordsAVByIndex.sum)

编辑

下一步是重命名重构 - 选择能更好地传达代码每个部分的名称。 Ken在评论中提出了更好的名称，并且我将它们用于另外一个变体（它还很好地展示了更好的命名提高了可读性）。

import scala.io.Source
def rawData = Source fromFile "names.txt" mkString

// I'd rather write "match" than "m" in the next snippet, but
// the former is a keyword in Scala, so "m" has become more
// common in my code than "i". Also, make the return type of
// getWordsOf clear, because iterators can be tricky.
// Returning a list, however, makes a much less cleaner
// definition.

def wordExtractor = """"(.*?)"""".r
def getWordsOf(input: String): Iterator[String] = for {
  m <- wordExtractor findAllIn input matchData
} yield m group 1
def wordList = getWordsOf(rawData).toList

// I stole letterPosition from Kevin's solution. There, I said it. :-)

def letterPosition(c: Char) = c.toUpper - 'A' + 1 // .toUpper isn't necessary
def alphabeticValueOfWord(word: String) = word map letterPosition sum
def alphabeticValues = wordList.sorted map alphabeticValueOfWord

// I don't like multAVByIndex, but I haven't decided on a better
// option yet. I'm not very fond of declaring methods that return
// functions either, but I find that better than explicitly handling
// tuples (oh, for the day tuples/arguments are unified!).

def multAVByIndex = (alphabeticValue: Int, index: Int) => 
  alphabeticValue * (index + 1)
def scores = alphabeticValues.zipWithIndex map multAVByIndex.tupled

println(scores sum)

Answer 4

除了Kevin的解决方案，

关键是要考虑到可重用性和可读性，清楚，整洁地分割功能。

为了使代码更简洁，更清晰，似乎可以使用for表达式。

def inputString(inputFile: String) = io.Source.fromFile(inputFile).getLines.mkString

def inputWords(input: String) = input.split("[,\"]").filter("" != )

Console.println {
    (for { (s, idx) <- inputWords(inputString("names.txt")).sorted.zipWithIndex }
        yield s.map(_ - 'A' + 1).sum * (idx + 1)).sum
}

s.map（_-'A'+ 1）部分可以进一步放入一个函数，比如wordSum，如果你想让它更加清晰。