标签: imperative

所以我正在努力教自己Haskell.我目前正在第11章" 了解你是一个好的Haskell",我正在做99个Haskell问题以及项目Euler问题.

事情进展顺利,但每当我需要跟踪"变量"时,我发现自己经常做一些事情.我只是创建另一个函数,接受那些"变量"作为参数,并根据情况递归地提供不同的值.举一个例子来说明,这是我对项目Euler的问题7的解决方案,找到第10001个素数:

answer :: Integer
answer = nthPrime 10001

nthPrime :: Integer -> Integer
nthPrime n
  | n < 1 = -1
  | otherwise = nthPrime' n 1 2 []


nthPrime' :: Integer -> Integer -> Integer -> [Integer] -> Integer
nthPrime' n currentIndex possiblePrime previousPrimes
  | isFactorOfAnyInThisList possiblePrime previousPrimes = nthPrime' n currentIndex theNextPossiblePrime previousPrimes
  | otherwise = 
    if currentIndex == n 
      then possiblePrime 
      else nthPrime' n currentIndexPlusOne theNextPossiblePrime …

功能编程..就像经典(马克吐温的类型).在阅读另一篇关于SICP的文章时,人们在谈论闭包对思维的影响,我得到了提醒,我读过很久以前

关闭是穷人的对象对象是穷人的关闭

(不记得确切的来源,但它是程序员,或编程的禅,或编程的tau ...谷歌已经变得如此拥挤,不能去原始来源)

所以共同编程人员......你有什么看法......关闭你总是缺少的东西......或者只是一些语法糖,这是一个预处理器可以做到的!

我是Scala的新手,只是阅读Scala By Example.在第2章中,作者有2个不同版本的Quicksort.

一个是势在必行的风格:

def sort(xs: Array[Int]) {
    def swap(i: Int, j: Int) {
        val t = xs(i); xs(i) = xs(j); xs(j) = t
    }
    def sort1(l: Int, r: Int) {
        val pivot = xs((l + r) / 2)
        var i = l; var j = r
        while (i <= j) {
            while (xs(i) < pivot) i += 1
            while (xs(j) > pivot) j -= 1
            if (i <= j) {
                swap(i, j)
                i += 1
                j -= …

我遇到了以下问题:我有一个不同类的对象树,其中子类中的操作使父类无效.在命令式语言中,这样做很简单.例如,在Java中:

public class A {
    private List<B> m_children = new LinkedList<B>();
    private boolean m_valid = true;

    public void invalidate() {
        m_valid = false;
    }

    public void addChild(B child) {
        m_children.add(child);
        child.m_parent = this;
    }
}

public class B {
    public A m_parent = null;
    private int m_data = 0;

    public void setData(int data) {
        m_data = 0;
        m_parent.invalidate();
    }
}

public class Main {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(); …

纯函数式编程语言不允许可变数据,但某些计算以命令式方式更自然/直观地表达 - 或者算法的命令式版本可能更有效.我知道大多数函数式语言都不是纯粹的,让你分配/重新分配变量并执行命令性的事情,但通常会阻止它.

我的问题是,为什么不允许本地状态在局部变量中被操作,但是要求函数只能访问它们自己的局部和全局常量(或者只是在外部范围中定义的常量)？这样,所有函数都保持引用透明性(它们在给定相同参数的情况下总是给出相同的返回值),但在函数内,计算可以用命令式术语表示(例如,while循环).

IO等仍然可以通过正常的功能方式完成 - 通过monad或绕过"world"或"universe"令牌.

将命令式算法转换为函数式风格我遇到了一些困难.我无法理解的主要概念是如何根据序列中的位置填充序列值.在Haskell中,以下算法的惯用解决方案如何？

A = unsigned char[256]
idx <- 1
for(i = 0 to 255)
    if (some_condition(i))
        A[i] <- idx
        idx++
    else
        A[i] = 0;

该算法基本上为直方图的映射函数创建查找表.

你知道哪些资源可以帮助我更好地理解这类问题吗？

通常与函数式语言相关的哪些技术或范例也可以在命令式语言中有效地使用？

例如:

• 在没有尾调用优化的语言中,递归可能会出现问题,将其使用限制在一组狭窄的案例中,因此其用途有限
• 地图和过滤器已经进入非功能语言,即使它们具有功能性的感觉

我碰巧真的不想担心功能语言中的状态.如果我特别顽固,我可能会编写C程序而不修改变量,只将我的状态封装在传递给函数的变量和函数返回的值中.

即使函数不是第一类值,我也可以在Java中用一个对象包装一个,并将其传递给另一个方法.像功能编程一样,只是不那么有趣.

那么,对于函数式编程的资深人士来说,当您使用命令式语言进行编程时,FP的哪些想法已成功应用？

我正在为几个星期开始的课程写一些课程材料.我选择Clojure作为学生学习的新语言.我想用一章来重构命令式代码到功能代码.为此,我想提出一系列实用问题,这些问题并不遥远,我可以通过它来展示必要性和功能性解决方案的比较.优选地,问题不像项目Euler那样强调数学,而是普通程序员需要定期处理的问题.谁有这方面的好消息来源？

部分答案:一个这样的来源是http://langref.org/.更想要的!

我使用以下yaml 创建kubectl create -f pod.xml并kubectl apply -f pod.xml使用了pod，但没有发现任何区别，两个命令都创建了pod。该K8S文件，提到了命令性和声明的命令。但是，创建和应用的行为仍然相同。

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp
spec:
  containers:
  - name: myapp-container
    image: busybox
    command: ['sh', '-c', 'echo Hello Kubernetes! && sleep 3600']

有什么不同？另外，kubectl apply声明式和kubectl create命令式又如何？他们两个都使用一个或多个带有对象详细信息的yaml文件。

我正在使用Exercism来学习F#.Nth Prime的挑战是建立一个Eratosthenes筛子.单元测试让你搜索第1,001个素数,即104,743.

我修改了一个代码片段,我记得从F#For Fun和Profit批量工作(需要10k素数,而不是25)并将它与我自己的命令式版本进行比较.性能差异显着:

(BenchmarkDotNet v0.11.2)

有没有一种有效的方法来这样做？我喜欢F#.我喜欢使用F#库保存多少时间.但有时我看不到有效的惯用路线.

这是惯用的代码:

// we only need to check numbers ending in 1, 3, 7, 9 for prime
let getCandidates seed = 
    let nextTen seed ten = 
        let x = (seed) + (ten * 10)
        [x + 1; x + 3; x + 7; x + 9]
    let candidates = [for x in 0..9 do yield! nextTen seed x ]
    match candidates with 
    | 1::xs -> xs  //skip 1 …