标签: function-composition

为了理解函数式编程的功能,我将一些基本函数组合在一起,您可以将它们组合在一起构建复杂的正则表达式.现在经过一些测试我发现它有效,但你可以用任何可行的语言编写一些可怕的代码.这是你会找到专业的F#程序员写的代码还是我滥用这个功能？

注意: test具体是我指的是什么.

type State = { input:string; index:int; succeeded:bool }
type Matcher = State -> State

let term (cs:char Set)  =
    fun s ->
        if s.succeeded && s.index < s.input.Length && cs.Contains s.input.[s.index] then  
            { input = s.input; index = s.index + 1; succeeded = true }
        else 
            { input = s.input; index = s.index; succeeded = false }

let quantify (term, min, max) =
    let rec inner (s:State, count) =
        if s.succeeded && s.index < s.input.Length && …

以下代码:

import Control.Exception
import Data.List

updateAverage :: (Fractional t) => (t, t) -> t -> (t, t)
updateAverage (old_value, old_counter) x =
    let new_counter = old_counter + 1
    in 
        assert(new_counter /= 0)
        old_value `seq` (old_value + (x - old_value) / new_counter, new_counter)

average values = fst (foldl' updateAverage (0.0, 0.0) values) -- version I

main = do
    let v = [1 .. 1000000]
    let a = average v
    putStrLn (show a)

ghc.exe -O3当我用average函数的定义替换时,变得更快(编译选项:)

average = fst . …

几个月前,我读到了一个有效的方法,通过用函数组合表示它们来添加和预先将列表添加到O(1)中的其他列表,这些函数组合一旦被评估,就在O(n)中生成结果列表.

不幸的是,我不记得这篇文章的来源或(如果存在的话)这种技术/方法的名称.你有关于它的参考吗？

我想知道Haskell是否跟踪天气函数是一个函数组合,即我是否可以定义一个与此类似的函数？:

compositionSplit f.g = (f,g)

我正在学习Scala并遇到以下任务 - 如果string为空,则返回null,否则返回大写.

Apache Commons中有两个功能组合在一起解决了这个问题.在Haskell中,我只想写:

upperCaseOrNull = StringUtils.stripToNull . StringUtils.upperCase

但是我找不到在Scala中做一个简单而干净的函数组合的方法.我发现的最短路径如下:

def upperCaseOrNull (string:String) = StringUtils.stripToNull (StringUtils.upperCase(string))
def upperCaseOrNull = StringUtils.stripToNull _ compose StringUtils.upperCase _

Scala是否提供更简洁的语法,可能没有所有这些下划线？

如果我们有两个功能,f并且g,然后在Haskell h = f . g相当于h x = f(g x).即功能从右到左应用于输入.有什么根本原因可以从右到左,而不是从左到右？也就是说他们为什么不h = f . g相同h x = g(f x)呢？

编辑:正如其他人指出我的等效功能错误的方式,所以我修复了那些.

我想了解如何以无点方式完成以下工作:

withinBounds :: [Int] -> Bool
withinBounds xs = (all (>= 0) xs) && (all (<= 8) xs)

我明白,出于可读性/理智的考虑,以这种方式编写它是优越的,但我想更多地了解如何编写函数.我一直在摸索着如何做到这一点.整个(扩展？)类型签名是

[Int] -> ([Int] -> Bool) -> ([Int] -> Bool) -> (Bool -> Bool -> Bool) -> Bool

我想要的组合的类型签名是

(a -> b) -> (a -> c) -> (b -> c -> d) -> (a -> d)

我用以混蛋 - lambda形式的笔记写下了以下内容.如果有一种方法可以在某种程度上简化lambda演算的问题,那么如果可以解释它也会很棒:

\L@[] ->  \f1@([] -> Bool) -> \f2@([] -> Bool) -> \f3@(Bool -> Bool -> Bool) -> f3.(f1.L).(f2.L) 

在上面,.是应用程序,@正在捕获(所以f3是(Bool - …

如何根据某些逻辑条件停止或分支合成？

例如.假设我有以下代码:

compose(
  operation4
  operation3,
  operation2,
  operation1
)(myStuff);

甚至是类似的东西

myStuff
 .map(operation1)
 .map(operation2)
 .map(operation3)
 .map(operation4)

如果myStuff满足某些条件,我只希望执行操作3和4.

我该如何实现(特别是在JavaScript中)？

我是否必须创建两个较小的组合并具有单独的if语句,或者是否有办法在组合中包含条件？

Monads可以解决我的问题吗？如果是这样,怎么样？

以前问了类似的问题,但不知怎的,我没有找到出路,再次尝试另一个例子.

可以在https://ideone.com/zkQcIU上找到代码作为起点(稍微修整一下).

(它有一些问题识别Microsoft.FSharp.Core.Result类型,不知道为什么)

基本上所有操作都必须通过前一个函数进行流水线操作,将结果输送到下一个操作.操作必须是异步的,如果发生异常,它们应该向调用者返回错误.

要求是给调用者结果或错误.所有函数返回填充任何一个元组的成功 type Article或失败有type Error其描述对象code,并message从服务器返回.

我将在一个答案中欣赏我的代码中的被调用者和调用者的工作示例.

被叫代码

type Article = {
    name: string
}

type Error = {
    code: string
    message: string
}

let create (article: Article) : Result<Article, Error> =  
    let request = WebRequest.Create("http://example.com") :?> HttpWebRequest
    request.Method <- "GET"
    try
        use response = request.GetResponse() :?> HttpWebResponse
        use reader = new StreamReader(response.GetResponseStream())
        use memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(reader.ReadToEnd())) 
        Ok ((new DataContractJsonSerializer(typeof<Article>)).ReadObject(memoryStream) :?> Article)
    with …

我试图用类型(Floating a) => a -> a -> a的函数组成一个类型的函数(Floating a) => a -> a来获得类型的函数(Floating a) => a -> a -> a.我有以下代码:

test1 :: (Floating a) => a -> a -> a
test1 x y = x

test2 :: (Floating a) => a -> a
test2 x = x

testBoth :: (Floating a) => a -> a -> a
testBoth = test2 . test1
--testBoth x y = test2 (test1 x y)

但是,当我在GHCI中编译它时,我收到以下错误:

/path/test.hs:8:11:
    Could not …