javascript

java

python

c#

android

c++

node.js

php

html

jquery

ios

reactjs

css

.net

git

ruby-on-rails

sql

c

ruby

string

UML可以用于对功能程序进行建模吗?

更具体地说,您如何为一个函数程序建模,或者是使用图表而不是文本表示法使用函数式样式(无类)开发的程序,是否有可能,请有人将我定向到可以执行此操作的最近应用程序 (如果需要的话,开源,与啤酒一样免费)

trans by 2020-02-03T14:24:17Z

红宝石-如何传递函数而不是b

可能重复:
将数组的每个元素传递给函数的更短方法

我知道这会起作用:

def inc(a)
  a+1
end
[1,2,3].map{|a| inc a}

但是在Python中,我只需要编写:

map(inc, [1,2,3])

要么

[inc(x) for x in [1,2,3])

我想知道是否可以跳过在Ruby中制作块的步骤,并且这样做:

[1,2,3].map inc
# => ArgumentError: wrong number of arguments (0 for 1)
# from (irb):19:in `inc'

有人对如何做到这一点有想法吗?

trans by 2020-02-02T12:50:48Z

函数式编程-G中的一流函数

我来自具有一流功能支持的JavaScript。 例如,您可以:

  • 将一个函数作为参数传递给另一个函数
  • 从函数返回一个函数。

有人可以给我一个例子,说明我将如何在Go中执行此操作吗?

trans by 2020-01-27T23:04:47Z

java-是否有可证明的现实世界语言? (斯卡拉?)

我在大学里被教过关于正规系统的知识,但令我感到失望的是,它们似乎并没有被真正的单词使用。

我喜欢能够知道某些代码(对象,函数等)的想法,而不是通过测试,而是通过证明。

我确信我们都熟悉物理工程和软件工程之间不存在的相似之处(钢铁的行为可预测,软件可以做任何事情-谁知道!),我很想知道是否有任何语言可以 可以用真实的词来使用(是否要求太多Web框架?)

我听说过有关scala等功能语言的可测试性的有趣信息。

作为软件工程师,我们有哪些选择?

trans by 2020-01-26T06:22:43Z

java-实现这种可重试调用的Scala方法是什么?

还是Scala的新手,我现在正在寻找一种在其上实现以下代码的方法:

@Override
public void store(InputStream source, String destination, long size) {

    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(size);
    final PutObjectRequest request = new PutObjectRequest(
            this.configuration.getBucket(), destination, source, metadata);

    new RetryableService(3) {

        @Override
        public void call() throws Exception {
            getClient().putObject(request);
        }
    };

}

在Scala中实现与Retryable Service实现的功能相同的最佳方法是什么?

它基本上调用N次调用方法,如果所有方法均失败,则引发异常,如果它们均成功,则继续进行。 这个不返回任何东西,但是我有另一个版本可以返回值(因此,我在Java中有两个类),我相信我可以在Scala中使用单个类/函数。

有任何想法吗?

编辑

Java当前的实现如下:

public abstract class RetryableService {

private static final JobsLogger log = JobsLogger
        .getLogger(RetryableService.class);

private int times;

public RetryableService() {
    this(3);
}

public RetryableService(int times) {
    this.times = times;
    this.run();
}

private void run() {

    RuntimeException lastExceptionParent = null;

    int x = 0;

    for (; x < this.times; x++) {

        try {
            this.call();
            lastExceptionParent = null;
            break;
        } catch (Exception e) {
            lastExceptionParent = new RuntimeException(e);
            log.errorWithoutNotice( e, "Try %d caused exception %s", x, e.getMessage() );

            try {
                Thread.sleep( 5000 );
            } catch (InterruptedException e1) {
                log.errorWithoutNotice( e1, "Sleep inside try %d caused exception %s", x, e1.getMessage() );
            }

        }

    }

    try {
        this.ensure();
    } catch (Exception e) {
        log.error(e, "Failed while ensure inside RetryableService");
    }

    if ( lastExceptionParent != null ) {
        throw new IllegalStateException( String.format( "Failed on try %d of %s", x, this ), lastExceptionParent);
    }   

}

public void ensure() throws Exception {
    // blank implementation
}

public abstract void call() throws Exception;

}
trans by 2020-01-24T23:18:04Z

python-此lambda / yield / generator理解如何工作?

我今天在浏览我的代码库,发现了这一点:

def optionsToArgs(options, separator='='):
    kvs = [
        (
            "%(option)s%(separator)s%(value)s" %  
            {'option' : str(k), 'separator' : separator, 'value' : str(v)}
        ) for k, v in options.items()
    ]
    return list(
        reversed(
            list(
                    (lambda l, t: 
                        (lambda f: 
                            (f((yield x)) for x in l)
                        )(lambda _: t)
                    )(kvs, '-o')
                )
            )
        )

似乎要听一些参数,然后将它们变成shell命令的参数列表。 看来它正在生成器理解中使用yield,我认为这是不可能的...?

>>> optionsToArgs({"x":1,"y":2,"z":3})
['-o', 'z=3', '-o', 'x=1', '-o', 'y=2']

它是如何工作的?

trans by 2020-01-24T02:28:29Z

语法-在Haskell中是否有一种使函数签名更具信息性的好方法?

我意识到这可能被认为是一个主观的问题,或者是一个离题的问题,因此我希望与其关闭它,不如将其移植到程序员。

我开始学习Haskell,主要是为了自己的学习,并且我喜欢支持该语言的许多思想和原则。 在参加与Lisp一起进行的语言理论课程后,我对函数式语言着迷,并且我听到了很多关于Haskell可以如何高效工作的好消息,因此我想自己进行调查。 到目前为止,除了一种我无法摆脱的事情之外,我喜欢这种语言:那些母亲会发出函数签名。

我的专业背景主要是面向对象的,尤其是在Java中。 我工作过的大多数地方都采用了许多标准的现代教条。 经过几年的这种工作方式,它绝对成为我的舒适之地。 特别是“好的”代码应该自我记录的想法。 我已经习惯了在IDE中工作,在IDE中,带有描述性很强的冗长而冗长的方法名称不是问题,它具有智能自动完成功能以及用于导航包和符号的大量分析工具。 如果我可以在Eclipse中按Ctrl + Space,然后通过查看方法的名称以及与其参数相关联的局部作用域变量(而不是拉出JavaDocs)来推断方法的作用,那么我就像在大便中大吃一惊。

这绝对不是Haskell社区最佳实践的一部分。 我已经阅读了许多有关此问题的不同意见,并且我了解Haskell社区认为其简洁性是“赞成”的。 我已经读完了《如何阅读Haskell》一书,并且我了解了许多决定的依据,但这并不意味着我喜欢它们。 一个字母的变量名等对我来说并不有趣。 我承认,如果我想继续使用该语言,就必须习惯这一点。

但是我无法克服函数签名。 举个例子,摘自“学习Haskell [...]”部分的函数语法:

bmiTell :: (RealFloat a) => a -> a -> String  
bmiTell weight height  
    | weight / height ^ 2 <= 18.5 = "You're underweight, you emo, you!"  
    | weight / height ^ 2 <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
    | weight / height ^ 2 <= 30.0 = "You're fat! Lose some weight, fatty!"  
    | otherwise                   = "You're a whale, congratulations!"

我意识到这是一个愚蠢的示例,仅出于解释防护和类约束的目的而创建,但是如果您仅检查该函数的签名,则不会知道它的哪个参数是权重。 或高度。 即使您要使用newtypeDouble而不是任何类型,也仍然无法立即分辨出来。

一开始,我以为我会很可爱,聪明又聪明,并尝试使用带有多个类约束的更长的类型变量名来欺骗它:

bmiTell :: (RealFloat weight, RealFloat height) => weight -> height -> String

这会吐出一个错误(顺便说一句,如果有人可以向我解释该错误,我将不胜感激):

Could not deduce (height ~ weight)
    from the context (RealFloat weight, RealFloat height)
      bound by the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
      at example.hs:(25,1)-(27,27)
      `height' is a rigid type variable bound by
               the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
               at example.hs:25:1
      `weight' is a rigid type variable bound by
               the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
               at example.hs:25:1
    In the first argument of `(^)', namely `height'
    In the second argument of `(/)', namely `height ^ 2'
    In the first argument of `(<=)', namely `weight / height ^ 2'

我不完全了解为什么这行不通,所以我开始在Google上搜索,甚至发现了这篇小文章,其中建议了命名参数,特别是通过newtype欺骗了命名参数,但这似乎有点多。

有没有可以接受的方法来制作信息功能签名? 是“ The Haskell Way”仅仅是为了让Haddock摆脱一切吗?

trans by 2020-01-23T07:34:00Z

scala-scalaz中的函数语法难题

看了尼克·帕蒂奇(Nick Partidge)关于衍生标度的演示之后,我来看了这个例子,真是太棒了:

import scalaz._
import Scalaz._
def even(x: Int) : Validation[NonEmptyList[String], Int] 
    = if (x % 2 ==0) x.success else "not even: %d".format(x).wrapNel.fail

println( even(3) <|*|> even(5) ) //prints: Failure(NonEmptyList(not even: 3, not even: 5))

我试图了解(_: A, _: B)方法在做什么,这是源代码:

def <|*|>[B](b: M[B])(implicit t: Functor[M], a: Apply[M]): M[(A, B)] 
    = <**>(b, (_: A, _: B))

好的,这相当令人困惑(!)-但它引用了(_: A, _: B)方法,该方法因此声明为:

def <**>[B, C](b: M[B], z: (A, B) => C)(implicit t: Functor[M], a: Apply[M]): M[C] 
    = a(t.fmap(value, z.curried), b)

所以我有几个问题:

  1. 为什么该方法似乎采用一种类型参数的较高类型((_: A, _: B))但可以通过(A, B) => Pair[A,B](具有两种类型参数)?
  2. 语法(_: A, _: B)定义了第二种方法期望的功能(A, B) => Pair[A,B]:在失败情况下Tuple2 / Pair发生了什么? 看不到元组!
trans by 2020-01-22T19:50:23Z

标量-值,类型,种类...作为无限序列?

我才刚刚开始熟悉种类的概念,所以如果我不能很好地提出问题,请多多包涵...

值具有类型:

3 :: Int
[1,2,3] :: [Int]
('c',True) :: (Char,Bool)

类型有种类:

the type 'Int' has kind *
the type '[Int]' also has kind *
   but the type constructor [] has kind * -> *
similarly, the type (Char,Bool) has kind  *
   but the type constructor (,) has kind * -> * -> *

有什么?

它们是否具有同类,流派,品种或变种?

这个抽象序列走了多远? 我们是因为语言用完而停止还是因为走得更远而没有价值而停止? 或者,也许是因为我们很快就达到了人类认知的极限,只是无法将自己的头脑包裹在更高类型的事物上?

一个相关的问题:语言为我们提供了价值建构者(如cons运算符)来创造价值。 语言还为我们提供了类型构造器,例如(,)或[]来进行类型构造。 是否有任何语言可以将种类构造函数暴露为种类?

我很好奇的另一个极端情况是:我们显然有一个没有值的类型,称为⊥,称为“底部类型”。 是否有没有类型的东西:底部类型?

trans by 2020-01-20T09:11:09Z

C ++中的函数式编程

有人可以指导我如何使用C ++进行函数式编程吗? 我可以参考一些好的在线资料吗?

请注意,我了解FC ++库。 我想知道如何仅使用C ++标准库来做到这一点。

谢谢。

trans by 2020-01-19T01:57:34Z

小型和优秀的Scala项目以学习Scala-尤其是函数式编程和类型系统

我已经学习了Scala几个月,但是仍然是初学者。 现在,我发现我在函数式编程和Scala的类型系统方面遇到了很大的麻烦。

我尝试查找一些文档和博客,但是我大部分内容(尤其是类型系统的文档)无法理解。 因此,我正在寻找一些小型且出色的Scala项目,我可以阅读这些源以学习。

你能推荐我一些吗?

trans by 2020-01-17T21:00:22Z

功能性编程-Java中的深度递归导致堆栈溢出?

在对函数式语言有一定的经验之后,我开始在Java中更多地使用递归-但是该语言似乎只有约1000个相对较浅的调用堆栈。

有没有办法使调用堆栈更大? 就像我可以像在Erlang中一样,进行数百万次调用的函数吗?

当我处理Project Euler问题时,我越来越注意到这一点。

谢谢。

trans by 2020-01-16T18:53:28Z

编程语言-Scala中的def foo = {}和def foo()= {}有什么区别?

给定以下用于在Scala中定义函数的构造,您能否解释一下两者之间的区别以及所带来的影响?

def foo = {}

def foo() = {}

更新资料

感谢您的快速回复。 这些很棒。 我唯一剩下的问题是:

如果我省略括号,还有办法传递函数吗? 这是我得到的代表:

scala> def foo = {}
foo: Unit

scala> def baz() = {}
baz: ()Unit

scala> def test(arg: () => Unit) = { arg }
test: (arg: () => Unit)() => Unit

scala> test(foo)
<console>:10: error: type mismatch;
 found   : Unit
 required: () => Unit
              test(foo)
                   ^

scala> test(baz)
res1: () => Unit = <function0>

更新2012-09-14

这是我注意到的一些类似问题:

  1. 带括号和不带括号的函数之间的区别
  2. 没有参数的Scala方法
trans by 2020-01-16T01:49:51Z

f#-您如何设计功能程序?

从编程生涯的第一天开始,我就开始进行面向对象的编程。 但是,我对学习其他范例感兴趣(我在这里多次说过这是一件好事,但我没有时间做)。 我认为我不仅准备就绪,而且有时间,所以我将开始使用F#进行函数式编程。

但是,我不确定如何构造更少的设计应用程序。 我习惯于OO编程中的“每文件一个类”和“名词/功能-动词”的思想。 您如何设计和构建功能应用程序?

trans by 2020-01-15T06:52:40Z

函数式编程-混合Erlang和Has

如果您已经购买了函数式编程范例,那么您很可能同时喜欢Erlang和Haskell。 两者都具有纯功能内核和其他优点,例如轻量级线程,使其非常适合多核世界。 但是也有一些差异。

Erlang是一种经过商业验证的容错语言,具有成熟的分发模型。 它具有看似独特的功能,可以在运行时通过热代码加载来升级其版本。 (真酷!)

另一方面,Haskell具有所有主流语言中最复杂的类型系统。 (在这里我将“主流”定义为出版了O'Reilly书的任何语言,因此Haskell可以算作。)它的直线单线程性能看起来比Erlang更好,而轻量级的线程看起来也更轻。

我正在尝试为我的余下编码生涯建立一个开发平台,并且想知道是否有可能将Erlang和Haskell混合使用以获得最佳平台。 这个问题分为两个部分:

  1. 我想将Erlang用作一种容错MPI,以将GHC运行时实例粘合在一起。 每个GHC运行时将有一个Erlang进程。 如果“不可能的事情发生了”并且GHC运行时终止,那么Erlang进程将以某种方式检测到该错误并死亡。 Erlang的热代码加载和分发功能将继续起作用。 可以将GHC运行时配置为仅使用一个内核,或使用本地计算机上的所有内核,或两者之间的任意组合。 编写完Erlang库之后,其余的Erlang级代码应该完全是样板文件,并应根据每个应用程序自动生成。 (例如,可能是通过Haskell DSL。)如何至少实现其中某些功能?
  2. 我希望Erlang和Haskell能够共享同一个垃圾收集器。 (与1相比,这是一个更进一步的想法。)在JVM和CLR上运行的语言通过共享运行时来实现更大的质量。 我了解在JVM或CLR上运行Erlang(热代码加载)和Haskell(更高种类的多态性)存在技术限制。 但是,仅对垃圾收集器进行捆绑处理又如何呢? (为功能语言运行时的开始排序。)显然,分配仍然必须非常快,因此可能需要静态链接该位。并且应该有一些机制来区分可变堆和不可变堆( 包括延迟写入一次内存),因为GHC需要这样做。 修改HIPE和GHC以使垃圾收集器可以共享堆是否可行?

请回答任何经验(正面或负面),想法或建议。 实际上,欢迎您提供任何反馈意见(不要直接滥用!)。

更新资料

感谢您迄今收到的所有4封回复-每封都教给我至少一项我不知道的有用的东西。

关于编码生活中的其他事情-我在舌头上略加提及以引发辩论,但这是真的。 我想到的一个项目是我打算继续工作直到死,而且它需要一个稳定的平台。

在我上面提出的平台中,我只会写Haskell,因为样板将自动生成。 那么Haskell能持续多久? Lisp仍然在我们身边,并且看起来它不会很快消失。 Haskell是BSD3开源软件,已经达到了临界质量。 如果编程本身仍在50年后,我预计Haskell或Haskell的一些不断发展将仍然存在。

更新2以回应rvirding的帖子

同意-实施一个完整的“ Erskell / Haslang”通用虚拟机可能不是绝对不可能的,但确实确实非常困难。 像VM一样仅共享垃圾收集器级别,虽然仍然很困难,但听起来对我来说却要困难一个数量级。 在垃圾回收模型中,功能语言必须有很多共同点-不变数据(包括thunk)的唯一性以及对快速分配的要求。 因此,通用性与整体式VM紧密捆绑在一起的事实似乎有些奇怪。

虚拟机确实有助于达到临界质量。 只需看看F#和Scala等“精简”功能语言的发展情况。 Scala可能没有Erlang的绝对容错能力,但是它为与JVM有联系的许多人提供了一条逃生路线。

虽然只有一个堆   消息传递很快   引入了许多其他问题,   主要是做GC变得更多   很难,因为它必须是交互式的   并且在全球范围内无中断,因此您   不能使用更简单的算法   作为每个进程的堆模型。

绝对,这对我来说很有意义。 GHC开发团队中非常聪明的人似乎正在尝试通过并行的“阻止世界” GC解决部分问题。

[http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel-gc/par-gc-ismm08.pdf]

(鉴于主要的用例,显然“停止世界”不会适用于通用的Erlang。)但是即使在“停止世界”可以使用的用例中,其提速似乎也不是普遍的。 因此,我同意你的看法,不可能有一个通用的最佳GC,这就是我在问题的第1部分中指出的原因,

GHC运行时可以配置为   仅使用一个核心,或全部使用   本地计算机,或   之间。

这样,对于给定的用例,在进行基准测试后,我可以选择采用Erlang方式,并在每个内核上运行一个GHC运行时(使用单线程GC)加上一个Erlang进程,并让Erlang在内核之间复制内存以获得良好的局部性。 。

或者,在每个处理器具有4个核且处理器上具有良好内存带宽的双处理器计算机上,基准测试可能会建议我每个处理器运行一个GHC运行时(带有并行GC)和一个Erlang进程。

在这两种情况下,如果Erlang和GHC可以共享堆,则共享可能会以某种方式绑定到在单个内核上运行的单个OS线程。 (我不在这里,这就是为什么我问这个问题。)

我还有另一个议程-独立于GC的功能语言基准测试。 我经常阅读OCaml v GHC v Erlang v ...的基准测试结果,并且想知道不同的GC对结果有多大混淆。 如果GC的选择可以与功能语言的选择正交呢? 无论如何,GC有多昂贵? 看到这个恶魔拥护者博客文章

[http://john.freml.in/garbage-collection-harmful]

由我的Lisp朋友约翰·弗雷姆林(John Fremlin)所著,他的职位标题为“自动垃圾收集就是垃圾”。 当John声称GC运行缓慢并且没有真正加快速度时,我希望能够提供一些帮助。

trans by 2020-01-14T10:05:27Z

C ++-绑定Vs Lambda?

我有一个关于首选样式的问题:std :: bind与C ++ 0x中的lambda。 我知道它们的用途有所不同,但让我们举一个相交的功能为例。

使用lambda

uniform_int<> distribution(1, 6);
mt19937 engine;
// lambda style
auto dice = [&]() { return distribution(engine); };

使用bind

uniform_int<> distribution(1, 6);
mt19937 engine;
// bind style
auto dice = bind(distribution, engine);

我们应该选择哪一个? 为什么? 与上述示例相比,假设情况更为复杂。 即,一个相对于另一个的优点/缺点是什么?

trans by 2020-01-13T15:42:02Z

javascript-获取函数的参数

在Javascript中,如何确定为一个函数定义的形式参数的数量?

请注意,调用函数时,这不是arguments参数,而是定义了函数的命名实参的数量。

function zero() {
    // Should return 0
}

function one(x) {
    // Should return 1
}

function two(x, y) {
    // Should return 2
}
trans by 2020-01-12T20:42:23Z

函数式编程-如何在JavaScript函数调用中预先设置参数? (部分功能申请)

我正在尝试编写一个JavaScript函数,该函数将返回其第一个参数(函数),并将其所有其他参数作为该函数的预设参数。

所以:

function out(a, b) {
    document.write(a + " " + b);
}

function setter(...) {...}

setter(out, "hello")("world");
setter(out, "hello", "world")();

将输出两次“ hello world”。 对于二传手的一些实现

我第一次尝试操作arguments数组时遇到了一个问题,但是似乎会有更好的方法来做到这一点。

trans by 2020-01-05T00:28:32Z

函数式编程,Scala映射和折叠

左上角有哪些好的教程?

原始问题,已从删除中恢复以提供其他答案的上下文:

我正在尝试实现一种方法,用于找到矩形,圆形,位置以及全部扩展Shape的组的边界框。 组基本上是形状的数组

abstract class Shape  
case class Rectangle(width: Int, height: Int) extends Shape  
case class Location(x: Int, y: Int, shape: Shape) extends Shape  
case class Circle(radius: Int) extends Shape  
case class Group(shape: Shape*) extends Shape  

我得到了除第一组外的所有三个框的边界框。 因此,现在对于边界框方法,我知道我应该使用map并向左折叠Group,但是我只是无法找到创建它的确切语法。

object BoundingBox {  
  def boundingBox(s: Shape): Location = s match {  
    case Circle(c)=>   
      new Location(-c,-c,s)  
    case Rectangle(_, _) =>  
      new Location(0, 0, s)  
    case Location(x, y, shape) => {  
      val b = boundingBox(shape)  
      Location(x + b.x, y + b.y, b.shape)  
    }  
    case Group(shapes @ _*) =>  ( /: shapes) { } // i dont know how to proceed here.
  }
}

群组边界框基本上是所有形状都包含在内的最小边界框。

trans by 2019-12-30T01:06:14Z

函数式编程的核心概念是什么?

在面向对象的编程中,我们可以说核心概念是:

  1. 封装
  2. 遗产,
  3. 多态性

函数编程会是什么?

trans by 2019-12-29T18:47:05Z

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