标签: purely-functional

我有一个java.util.HashMap对象m(调用Java代码的返回值),我想获得一个带有附加键值对的新映射.

如果m是Clojure地图,我可以使用:

(assoc m "key" "value")

但试着这样做HashMap:

java.lang.ClassCastException:java.util.HashMap无法强制转换为clojure.lang.Associative

没有运气seq:

(assoc (seq m) "key" "value")

java.lang.ClassCastException:clojure.lang.IteratorSeq无法强制转换为clojure.lang.Associative

我设法做到的唯一方法是使用HashMap自己的put,但返回void所以我必须明确返回m:

(do (. m put "key" "value") m)

这不是惯用的Clojure代码,m而是我正在修改而不是创建新的地图.

如何HashMap使用更多Clojure-ish方式？

跳过列表(Pugh,1990)提供了具有对数时间操作的排序字典,如搜索树,但跳过列表更适合并发更新.

是否有可能创建一个有效的纯功能并发跳过列表？如果没有,是否有可能创建任何类型的高效纯函数并发排序字典？

我更倾向于尽可能地接近功能范例,当我的大脑迎接挑战时,尽可能地挤压到纯粹的功能.我尽可能使用F#.通常,我会遇到VB.NET或C#(或VBA,当我真的不走运时).所以我的语言让我偏离了功能方法.

从历史上看,我已经忽略了日志记录并与用户通信,直到我得到结果 - 让用户等待.现在我正在尝试实现状态栏的记录和/或更新.这很容易,因为我的语言允许我随时写入标准输出.但是从一个纯粹的功能角度来看,如何将一个人的功能泄露到外部世界？在计算过程中记录或与用户通信是否与纯功能方法相反？

我敢肯定在Haskell中会使用Monad.使用其他语言时呢？

谢谢.

我如何"杀死"一个耗时太长的纯计算？我试过了

import System.Timeout

fact 0 = 1
fact n = n * (fact $ n - 1)

main = do maybeNum <- timeout (10 ^ 7) $ (return . fact) 99999999
          print maybeNum

但是,这不起作用.替换(return . fact) 99999999为"真正的"IO功能getLine,这可以按预期工作.

由于我喜欢在Scala中编程,在我的Google采访中,我让他们给我一个Scala /函数式编程风格的问题.我得到的Scala功能样式问题如下:

您有两个由字母字符组成的字符串以及一个表示退格符号的特殊字符.我们将这个退格字符称为"/".当您到达键盘时,键入此字符序列,包括退格/删除字符.要实现的解决方案必须检查两个字符序列是否产生相同的输出.例如,"abc","aa/bc"."abb/c","abcc /","/ abc"和"// abc"都产生相同的输出"abc".因为这是一个Scala /函数编程问题,所以必须以惯用的Scala风格实现您的解决方案.

我写了下面的代码(可能不是我写的,我只是关闭内存).基本上我只是线性地通过字符串,将字符前置到列表,然后我比较列表.

def processString(string: String): List[Char] = {
  string.foldLeft(List[Char]()){ case(accumulator: List[Char], char: Char) =>
    accumulator match {
      case head :: tail => if(char != '/') { char :: head :: tail } else { tail }
      case emptyList => if(char != '/') { char :: emptyList } else { emptyList }
    }
  }
}

def solution(string1: String, string2: String): Boolean = {
  processString(string1) == processString(string2)
}

到现在为止还挺好？然后他询问时间复杂度,我回答线性时间(因为你必须处理每个字符一次)和线性空间(因为你必须将每个元素复制到一个列表中).然后他让我在线性时间内做,但是有恒定的空间.我想不出一种纯粹功能性的方法.他说尝试在Scala集合库中使用一个函数,如"zip"或"map"(我明确地记得他说过"zip"这个词).

这就是事情.我认为在没有任何可变状态或副作用的情况下,在恒定空间内进行它是不可能的.就像我认为他弄乱了这个问题.你怎么看？

你可以在线性时间内解决它,但是空间恒定吗？

我经常在Haskell代码中找到这种模式:

options :: MVar OptionRecord
options = unsafePerformIO $ newEmptyMVar

...

doSomething :: Foo -> Bar
doSomething = unsafePerformIO $ do
  opt <- readMVar options
  doSomething' where ...

基本上,一个人有一个选项或类似的记录,最初是在程序开始时设置的.由于程序员很懒惰,他不想options在整个程序中携带记录.他定义了一个MVar保持它 - 由丑陋的使用定义unsafePerformIO.程序员确保状态只设置一次,并且在任何操作发生之前.现在程序的每个部分都必须unsafePerformIO再次使用,只是为了提取选项.

在我看来,这样的变量被认为是实用的纯粹(不要打败我).是否有一个库抽象出这个概念,并确保变量只设置一次,即在初始化之前没有调用,并且不需要写unsafeFireZeMissilesAndMakeYourCodeUglyAnd DisgustingBecauseOfThisLongFunctionName

作为Scala的初学者 - 功能方式,我有点困惑于是否应该将我的case类的函数/方法放在这样的类中(然后使用类似方法链接,IDE提示)或者它是否是更实用的方法定义case类之外的函数.让我们考虑两种非常简单的环形缓冲区实现的方法:

1 /案例类内的方法

case class RingBuffer[T](index: Int, data: Seq[T]) {
  def shiftLeft: RingBuffer[T] = RingBuffer((index + 1) % data.size, data)
  def shiftRight: RingBuffer[T] = RingBuffer((index + data.size - 1) % data.size, data)
  def update(value: T) = RingBuffer(index, data.updated(index, value))
  def head: T = data(index)
  def length: Int = data.length
}

使用这种方法,您可以执行类似链接的方法,IDE将能够在这种情况下提示方法:

val buffer = RingBuffer(0, Seq(1,2,3,4,5))  // 1,2,3,4,5
buffer.head   // 1
val buffer2 = buffer.shiftLeft.shiftLeft  // 3,4,5,1,2
buffer2.head // 3

2 /案例类外的功能

case class …

这些天我正在学习Scala.我对Haskell略有熟悉,虽然我不能声称对它很了解.

那些不熟悉Haskell的人的括号

我在Haskell中喜欢的一个特点是,不仅功能是一等公民,而且副作用(让我称之为行动)也是如此.执行时将赋予您类型值的操作a属于特定类型IO a.您可以像其他任何值一样传递这些操作,并以有趣的方式组合它们.

事实上,结合副作用是Haskell用它们做某事的唯一方法,因为你无法执行它们.相反,将要执行的程序是由您的main函数返回的组合操作.这是一个巧妙的技巧,允许函数是纯粹的,同时让你的程序实际上做除了消耗功率之外的其他事情.

这种方法的主要优点是编译器知道您执行副作用的代码部分,因此它可以帮助您捕获它们的错误.

实际问题

在Scala中是否有某种方法可以让编译器类型为您检查副作用,以便 - 例如 - 您保证不会在某个函数中执行副作用？

我现在正在处理函数式编程的概念,并且发现它非常有趣,引人入胜且令人兴奋.特别是纯函数的概念在各方面都很棒.

但有一点我没有得到:如何在限制自己使用纯函数时处理副作用.

例如,如果我想计算两个数字的总和,我可以编写一个纯函数(在JavaScript中):

var add = function (first, second) {
  return first + second;
};

没问题.但是如果我想将结果打印到控制台怎么办？"根据定义将某些东西打印到控制台"的任务并不纯粹 - 但我怎么能/应该用纯函数式编程语言处理这个问题呢？

Kotlin初学者在这里.如何获取列表而不进行变更,创建第二个(不可变)列表,在特定索引处包含一个更新元素？

我正在考虑两种方式,这两种方式似乎都可能导致性能下降,改变底层对象,或两者兼而有之.

data class Player(val name: String, val score: Int = 0)

val players: List<Player> = ...

// Do I do this?
val updatedPlayers1 = players.mapIndexed { i, player ->
    if (i == 2) player.copy(score = 100)
    else player
}

// Or this?
val updatedPlayer = players[2].copy(score = 100)
val mutable = players.toMutableList()
mutable.set(2, updatedPlayer)
val updatedPlayers2 = mutable.toList()

如果没有高效的方法,那么Kotlin stdlib或其他库中是否有更合适的数据结构？Kotlin似乎没有载体.