javascript

java

python

c#

android

c++

node.js

php

html

jquery

ios

reactjs

css

.net

git

ruby-on-rails

sql

c

ruby

string

函数式编程-是否存在无法使用尾部递归编写的问题?

尾递归是功能语言中重要的性能优化策略,因为它允许递归调用消耗常量堆栈(而不是O(n))。

是否存在根本无法以尾递归样式编写的任何问题,还是总有可能将天真递归函数转换为尾递归函数?

如果是这样,那么有一天功能编译器和解释器是否足够智能,可以自动执行转换?

trans by 2020-06-21T03:31:15Z

函数式编程-C#中的不变对象模式-您如何看待?

在几个项目的过程中,我开发了一种用于创建不可变(只读)对象和不可变对象图的模式。 不可变的对象具有100%线程安全的优点,因此可以跨线程重用。 在我的工作中,我经常在Web应用程序中使用此模式进行配置设置以及我加载并缓存在内存中的其他对象。 缓存对象应该始终是不可变的,因为您要确保它们不会意外更改。

现在,您当然可以轻松地设计不可变对象,如以下示例所示:

public class SampleElement
{
  private Guid id;
  private string name;

  public SampleElement(Guid id, string name)
  {
    this.id = id;
    this.name = name;
  }

  public Guid Id
  {
    get { return id; }
  }

  public string Name
  {
    get { return name; }
  }
}

这对于简单的类来说很好-但是对于更复杂的类,我不喜欢通过构造函数传递所有值的概念。 在属性上具有二传手更可取,并且构造新对象的代码更易于阅读。

那么,如何使用setter创建不可变的对象?

好吧,在我的模式中,对象最初是完全可变的,直到使用单个方法调用冻结它们为止。 一旦冻结了对象,它将永远保持不变-无法再次将其变成可变对象。 如果需要该对象的可变版本,只需克隆它即可。

好的,现在来看一些代码。 在以下代码片段中,我试图将模式简化为最简单的形式。 IElement是所有不可变对象最终必须实现的基本接口。

public interface IElement : ICloneable
{
  bool IsReadOnly { get; }
  void MakeReadOnly();
}

Element类是IElement接口的默认实现:

public abstract class Element : IElement
{
  private bool immutable;

  public bool IsReadOnly
  {
    get { return immutable; }
  }

  public virtual void MakeReadOnly()
  {
    immutable = true;
  }

  protected virtual void FailIfImmutable()
  {
    if (immutable) throw new ImmutableElementException(this);
  }

  ...
}

让我们重构上面的SampleElement类以实现不可变对象模式:

public class SampleElement : Element
{
  private Guid id;
  private string name;

  public SampleElement() {}

  public Guid Id
  {
    get 
    { 
      return id; 
    }
    set
    {
      FailIfImmutable();
      id = value;
    }
  }

  public string Name
  {
    get 
    { 
      return name; 
    }
    set
    {
      FailIfImmutable();
      name = value;
    }
  }
}

现在,只要未通过调用MakeReadOnly()方法将对象标记为不可变的,就可以更改Id属性和Name属性。 一旦它是不可变的,则调用setter将产生ImmutableElementException。

最后说明:完整模式比此处显示的代码段更为复杂。 它还包含对不可变对象集合和不可变对象图的完整对象图的支持。 完整模式使您可以通过在最外面的对象上调用MakeReadOnly()方法来使整个对象图变得不可变。 一旦开始使用此模式创建较大的对象模型,泄漏对象的风险就会增加。 泄漏对象是在对对象进行更改之前未能调用FailIfImmutable()方法的对象。 为了测试泄漏,我还开发了用于单元测试的通用泄漏检测器类。 它使用反射来测试是否所有属性和方法都将ImmutableElementException抛出为不可变状态。换句话说,这里使用TDD。

我已经非常喜欢这种模式,并从中找到了很大的好处。 所以我想知道的是,你们中是否有人正在使用类似的模式? 如果是,您是否知道记录该文档的任何好的资源? 我实质上是在寻找潜在的改进以及该主题可能已经存在的任何标准。

trans by 2020-06-20T16:19:02Z

Ubuntu-如何使F#与Mono一起工作?

我似乎找不到单声道的编译器/插件。 是否存在?

trans by 2020-06-18T23:27:53Z

java-Java8中引入的lambda将更改或影响哪种GoF设计模式?

许多人声称,GoF设计模式的最大部分只是缺乏一流功能的解决方法。 现在,Java将要获得lambda表达式,其中哪些模式会受到它们的影响? 哪些可以大大简化或概括? 哪些基本保持不变? 欢迎任何实际的例子。

trans by 2020-06-18T22:45:58Z

函数式编程-Has中的动态调度

例如,用Java编写的程序在很大程度上依赖于动态调度。

此类程序如何用功能语言(例如Haskell)表达?

换句话说,Haskell在“动态调度”下表达思想的方式是什么?

trans by 2020-06-18T20:09:22Z

函数式编程-在Scala中使用部分函数-它如何工作?

我是Scala的新手,我使用的是2.9.1,并且我正设法了解如何使用部分函数。 我对咖喱函数有基本的了解,并且我知道部分函数有点像咖喱函数,它们只有2nary或类似的东西。 如您所知,我对此有点绿色。

似乎在某些情况下,例如XML过滤,能够部分使用功能将是非常有利的,因此我希望对如何使用它们有更好的了解。

我有一个使用RewriteRule结构的函数,但是我需要它使用两个参数,而RewriteRule结构只需要一个,或者是一个部分函数。 我认为这是我正在考虑提供帮助的案例之一。

欢迎任何建议,链接,智慧之言等!

到目前为止,答案是非常好的,并且已经消除了我的一些基本误解。 我认为他们也可以解释我在哪里苦苦挣扎-我认为也许发布一个更具体的新问题会有所帮助,所以我也会这样做。

trans by 2020-06-17T22:32:21Z

javascript-将Function.prototype.bind与参数数组一起使用?

与硬编码参数相反,如何使用参数数组调用Function.prototype.bind? (不使用ECMA6,因此没有传播算子)。

我正在尝试在使用回调的模块周围放置一个promises包装器,并且我想将传入的所有参数绑定到我的包装器方法中并对其进行绑定。 然后,我想用自己的回调函数调用部分应用的绑定函数,这将解决或拒绝一个Promise。

var find = function() {
  var deferred, bound;
  deferred = Q.defer();
  bound = db.find.bind(null, arguments);
  bound(function(err, docs) {
    if(err) {
      deferred.fail(err);
    } else {
      deferred.resolve(docs);
    }
  });
  return deferred.promise;
}

但是显然这是行不通的,因为bind需要参数而不是参数数组。 我知道我可以通过在参数数组的末尾插入回调并使用apply来做到这一点:

arguments[arguments.length] = function(err, docs) { ... }
db.find.apply(null, arguments);

或者通过遍历arguments数组并为每个参数重新绑定函数:

var bound, context;
for(var i = 0; i < arguments.length; i++) {
   context = bound ? bound : db.find;
   bound = context.bind(null, arguments[i]);
}
bound(function(err, docs) { ... })

但是这两种方法都很脏。 有任何想法吗?

trans by 2020-02-22T19:09:18Z

函数式编程-如何动态调用Python函数

我有以下代码:

fields = ['name','email']

def clean_name():
    pass

def clean_email():
    pass

如何动态调用clean_name()clean_email()

例如:

for field in fields:
    clean_{field}()

我使用了大括号,因为这是我以前在PHP中使用的方式,但是显然不起作用。

如何使用Python做到这一点?

trans by 2020-02-20T15:45:23Z

函数式编程-在OCam中设计大型项目

在OCaml中编写大型软件项目的最佳实践是什么?

您如何组织项目?

OCaml的哪些功能应该或不应该用于简化代码管理? 有什么例外 一流的模块? GADT? 对象类型?

建立系统? 测试框架? 宬?

我为haskell找到了很好的建议,我认为对OCaml拥有类似的东西会很好。

trans by 2020-02-19T16:44:47Z

scala-计算机上的“原因”一词是什么意思?

在学习函数式编程时,我经常碰到“原因”一词,尤其是在纯函数和/或引用透明性的情况下。 有人可以解释这到底是什么意思吗?

trans by 2020-02-17T09:30:02Z

功能编程中的“部分功能”到底是什么意思?

根据我的理解,部分函数是通过向函数传递比预期少的参数而获得的函数。 例如,如果这在Python中直接有效:

>>> def add(x,y):
...    return x+y
... 
>>> new_function = add(1)
>>> new_function(2)
3

在上面的代码段中,new_function是部分功能。 但是,根据Haskell Wiki,部分函数的定义是

部分函数是未针对指定类型的所有可能参数定义的函数。

因此,我的问题是:“部分函数”到底是什么意思?

trans by 2020-02-16T05:28:35Z

现实世界中的Haskell编程

多年来,当过当务之急的开发人员,我从未有过学习函数式编程的冲动。

几个月前,我终于决定学习Haskell。 这是一种很酷的语言,但是我对如何将事件驱动的真实应用程序编程为这种语言感到困惑。 您知道有关它的好教程吗?

注意:当我说“真实应用程序”时,我并不是说一个真实的,可投入生产的应用程序。 我只是说一个小示例应用程序,只是为了了解它。 我认为像Windows caculator的简化版本之类的东西会很棒,然后可能会更加复杂。

trans by 2020-02-15T18:42:32Z

oop-在函数式编程中实现多态

我目前正在享受从面向对象的语言到功能性语言的过渡。 呼吸着新鲜空气,我发现自己的工作效率比以前高得多。

但是,在FP方面,我还没有看到OOP的一个令人满意的答案,那就是多态性。 即我有大量的数据项集合,当将它们传递到某些函数中时,需要以完全不同的方式进行处理。 为了争辩,我们说有多种因素驱动多态行为,因此潜在地以指数形式出现了许多不同的行为组合。

在OOP中,可以使用多态性相对较好地处理:通过组合+继承或基于原型的方法。

在FP中,我介于两者之间:

  • 编写或组成可通过分支每个数据项的值来有效实现多态行为的纯函数-就像在组装巨大的条件甚至是模拟虚拟方法表一样!
  • 将函数以类似于原型的方式放入纯数据结构中-似乎可行,但是否也违反了将纯函数与数据分开定义的想法?

对于这种情况,推荐的功能方法是什么? 还有其他好的选择吗?

trans by 2020-02-15T11:43:28Z

javascript-一步定义和调用函数

Javascript中是否有一种方法可以定义一个函数并立即对其进行调用,从而可以重用它?

我知道您可以执行一次性匿名功能:

(function(i) {
    var product = i * i;
    console.log(product);
    // Can't recurse here because there's no (ECMA standard) way for the 
    // function to refer to itself
}(2)); // logs 4

或者,您可以命名一个函数,然后再调用它:

function powers(i) {
    var product = i * i;
    console.log(i * i);
    if (product < 1e6) { powers(product) };
}

powers(2); // Logs 4, 16, 256...

但是,有没有一种更干净的方法可以一次性定义和调用函数? 有点像两个例子的混合体?

无法执行此操作并不能阻止我执行任何操作,但是感觉这将是编写递归函数或需要在$(document).ready()上运行的函数的一种很好的表达方式,但在情况发生变化时等也可以。

trans by 2020-02-10T00:46:12Z

haskell-从种类上讲,FP中的monad是什么?

每当有人答应“解释单子”时,我的兴趣就会激起,只有当所谓的“解释”是一连串的例子而被挫败所取代时,这些附带的东西以“深奥的”背后的“数学理论”为结尾。 想法”“太复杂了,无法解释”。

现在,我要求相反。 我对类别理论有扎实的掌握,而且我不怕图追逐,米田引理或派生的函子(实际上是类别意义上的单子和附加词)。

有人可以给我一个清晰简洁的定义,就是函数编程中的monad是什么吗? 例子越少越好:有时一个清晰的概念说出一百多个胆小的例子。 尽管我并不挑剔,但Haskell作为演示语言还是不错的。

trans by 2020-02-09T03:09:37Z

haskell-自由定理的良好介绍

我偶然发现了函数语言中的免费定理的一个好主意。 但是,我唯一能找到的资源是Wadler的文章“免费定理”。 很好,但是绝对不是教程,这对我来说很难(我了解其中的一半,这需要我花很多时间)。 您能推荐我另一篇针对软件开发人员而不是核心函数语言研究人员的文章或教程吗?

谢谢。

trans by 2020-02-05T21:02:04Z

函数式编程-使用Either处理Scala鳕鱼中的故障

Either monad是一种出色的表达方式,可以处理Scala中的某些东西。 但是,如果什么都没有发生,而又需要记录一条消息怎么办? 根据Scala API文档,

Either类型通常用作   替代scala.Option在左边   表示失败(按照惯例),并且   权利类似于某人。

但是,我没有运气使用Either来找到最佳实践,也没有运气好的涉及Either的实际示例来处理故障。 最后,我为自己的项目提出了以下代码:

    def logs: Array[String] = {
        def props: Option[Map[String, Any]] = configAdmin.map{ ca =>
            val config = ca.getConfiguration(PID, null)
            config.properties getOrElse immutable.Map.empty
        }
        def checkType(any: Any): Option[Array[String]] = any match {
            case a: Array[String] => Some(a)
            case _ => None
        }
        def lookup: Either[(Symbol, String), Array[String]] =
            for {val properties <- props.toRight('warning -> "ConfigurationAdmin service not bound").right
                 val logsParam <- properties.get("logs").toRight('debug -> "'logs' not defined in the configuration").right
                 val array <- checkType(logsParam).toRight('warning -> "unknown type of 'logs' confguration parameter").right}
            yield array

        lookup.fold(failure => { failure match {
            case ('warning, msg) => log(LogService.WARNING, msg)
            case ('debug, msg) =>   log(LogService.DEBUG, msg)
            case _ =>
        }; new Array[String](0) }, success => success)
    }

(请注意,这是真实项目的摘录,因此不会自行编译)

非常感谢您了解您在代码中如何使用Either和/或关于重构以上代码的更好的主意。

trans by 2020-02-05T17:40:03Z

函数式编程-与计算机科学有关的Ruby yield特性

我最近发现了Ruby的块和屈服功能,我想知道:从计算机科学理论的角度来看,这适合什么? 它是一种功能编程技术,还是更具体的东西?

trans by 2020-02-05T01:23:21Z

动态-为什么动态输入Clojure?

我非常喜欢的一件事是阅读不同的编程语言。 目前,我正在学习Scala,但这并不意味着我对Groovy,Clojure,Python和许多其他语言不感兴趣。 所有这些语言都具有独特的外观和某些特色。 对于Clojure,我不了解这些设计决策之一。 据我所知,Clojure非常强调其功能范式,并且几乎迫使您尽可能使用不可变的“变量”。 因此,如果一半的值是不可变的,为什么要动态键入该语言?

Clojure网站说:

首先,Clojure是动态的。 这意味着Clojure程序不仅是您可以编译和运行的程序,而且还可以与之交互。

好吧,这听起来很奇怪。 如果程序已编译,则无法再进行更改。 当然,您可以与它进行“交互”,这就是UI的用途,但是该网站当然并不意味着一个整洁的“动态” GUI。

Clojure如何从动态打字中受益

我的意思是Clojure的特殊情况,而不是动态类型的一般优点。

动态类型系统如何帮助改善功能编程

同样,我知道不溢出“ int a”的乐趣。 遍及源代码,但类型推断可以减轻很多麻烦。 因此,我只想知道动态类型如何支持功能语言的概念。

trans by 2020-02-04T10:33:15Z

函数式编程-做什么(f。)。 在Haskell中是什么意思?

我已经看到根据模式(f .) . g定义了许多功能。例如:

countWhere = (length .) . filter
duplicate  = (concat .) . replicate
concatMap  = (concat .) . map

这是什么意思?

trans by 2020-02-03T22:41:54Z

上一页 1 2 3 4 5 6 7 8 9 10 11 12 下一页 共12页