标签: imperative-programming

我最近做了一个小算法,从一段代码中去掉函数参数,只保留最外面的函数.
我发现这个算法很容易以命令式方式设计.
但是,我对函数式编程非常感兴趣,我想知道如何以功能的方式完成同样的事情.

如果你能告诉我这样的算法是如何工作的,那将对我非常有帮助,所以我可能会更好地了解函数式编程的工作原理.此外,我想知道在设计算法时你的思考过程是什么.

我在Python中制作了命令式版本,但你的答案不一定是在python中; haskell或任何其他语言也会做得很好.

这是它的作用(将一个字符串作为输入并返回一个字符串):

"foo(a.d, b.e.fi()).go(sd, ds())"     -- returns -->  "foo().go()"
"foo(a, b).bar().fuu"                 -- returns -->  "foo().bar().fuu"
"foo.bar"                             -- returns -->  "foo.bar"

这是我的命令性代码:

def get_rid_of_arguments(text):
    i, start, end = 0, 0, 0
    result = ""
    for j, c in enumerate(text):
        if c == '(':
            if i == 0:
                start = j
                result += text[end:start]
            i += 1
        elif c == ')':
            i -= 1
            if i == 0:
                end = j + 1
                result += '()'
    return …

我试图找到将以下有状态命令式代码段转换为纯函数表示的最优雅方式（最好在 Haskell 中使用其 Monad 实现提供的抽象）。但是，我还不擅长使用转换器等组合不同的 monad。在我看来，在学习如何自己做时，分析他人对此类任务的看法最有帮助。命令式代码：

while (true) {
  while (x = get()) { // Think of this as returning Maybe something
    put1(x) // may exit and present some failure representation
  }
  put2() // may exit and present some success representation
}

当get返回时Nothing我们需要继续执行put2，当get返回时Just x我们希望x被传递给put1并且仅在put1失败或循环时才短路。基本上put1并且put2可能会终止整个事情或移动到以下语句以某种方式改变底层状态。get可以成功并调用put1和循环或失败并继续put2。

我的想法是：

forever $ do
  forever (get >>= put1)
  put2

为什么我要寻找这样的东西是因为 …

我在看Coursera中的Reactive Programming课程,它使用Scala实现Observer模式.在那里,Martin Odersky说观察者模式迫使命令式编程,我们可以看到,因为订阅者的处理程序有Unit类型.

他在这里说:https: //class.coursera.org/reactive-002/lecture/107 9:40

我真的不明白:

1.为什么处理者需要有Unit类型？

2. Observer模式如何强制命令式编程？

几乎是我第一次尝试在ocaml中编写命令式代码以尝试回答本网站上的问题,但我面临一个小问题.

let f() =
try
  while true do
    ()
  done
with
    _ -> 2

他不喜欢这样,因为他认为这个函数返回单元,就像它在try块中一样,但try块返回一个int.因此,如果我在"完成"之后添加3,它会起作用,但它真的很难看,因为3真的永远不会返回.

你怎么做到这一点 ？

在OCaml中是否有一种方法可以使函数内部的变量在函数调用之间保持其值？它应该像Pythons默认参数一样工作,它是在每个函数调用中对同一个对象的引用,或者函数应该是yield而不是显式返回一个值.效果应该如下(如果函数是返回自然数):

foo ();;
0
foo ();;
1

从某种意义上说，Haskell 是一种纯粹的函数式语言，当然，惯用代码试图尽可能合理地函数式。同时，Haskell 确实支持对其他语言中熟悉的一些命令式模式的相当直接的翻译，例如http://learnyouahaskell.com/a-fistful-of-monads#do-notation

（我知道，从某种意义上说，do 表示法“确实”仍然有效；这里的要点是，它允许相当直接地翻译一些命令式设计模式。）

我感兴趣的一种模式是函数需要更新外部变量，即存在于与其他代码共享的外部作用域中的变量。这可以用 Python 简单地演示：

def three():
    n = 0

    def inc():
        nonlocal n
        n += 1

    inc()
    inc()
    inc()
    return n

是否有可能通过某种 do 表示法的变体或其他方式在 Haskell 中实现上述设计模式？如果是这样，怎么办？

为了明确这个问题的范围：

我不是问在 Haskell 中解决上述问题的最佳方法是什么。显然，答案是three = 3。这只是一个例子。

我不是在问上面的设计模式是好还是坏。显然，这是一个见仁见智的问题。

我并不是问在编写 Haskell 时应该如何努力避免使用命令式设计模式。显然，这也是一个意见问题。

我只是想问上面的设计模式是否可以在Haskell中实现，如果可以，如何实现。

我已经做了很长时间的OOP(C++/Java/PHP/Ruby),并且很难想象Linux或Apache这样的大型程序和库是如何完全以命令式的方式编写的.什么是我可以看到的小型开源C项目,以了解C中的事情是如何完成的？

如果项目托管在GitHub上,则奖励积分.

我的书提供了一个简单的例子,我有点困惑:

它说,"考虑以下程序,并假设细粒度的原子动作正在读取和写入变量:"

int y = 0, z = 0;
co x = y+z; // y=1; z=2; oc;

"如果x = y + z通过使用y加载寄存器然后向其添加z来实现,则x的最终值可以是0,1,2或3."

2？2如何工作？

注意:co启动并发进程,//表示并行运行的语句

我想知道是否有一种优雅的方法来查看是否可以检查在 while 循环中不断变化的值，并在该值停止变化并保持不变时停止 while 循环。

例如：

Value = 0
while True:
    value changes everytime
    (if value still the same break)

我想查看列表有多长,但不使用该函数length.我写了这个程序,它不起作用.也许你可以告诉我为什么？谢谢!

let y = 0
main = do
  list (x:xs) = list (xs)
  y++

list :: [Integer] -> Integer
list [] = y