标签: function-composition

我很好奇为什么会这样

let f = (fun a b -> a, b) >> obj.Equals

给出了错误

没有名为'Equals'的可访问成员或对象构造函数需要1个参数

但这很有效

let f = (fun a -> a, a) >> obj.Equals

我试图使用折叠来取得Haskell中整数之和的平方.但是,我从GHCi那里得到了一个神秘的错误.这是我的单行:

((^2) . foldl) (+) 0 [1..100]

我从GHCi得到的是:

Prelude> ((^2) . foldl) (+) 0 [1..100]

<interactive>:19:3:
    No instance for (Num (b0 -> [b0] -> b0))
      arising from a use of `^'
    Possible fix:
      add an instance declaration for (Num (b0 -> [b0] -> b0))
    In the first argument of `(.)', namely `(^ 2)'
    In the expression: (^ 2) . foldl
    In the expression: ((^ 2) . foldl) (+) 0 [1 .. 100]

我认为问题出在我最后根据此类型声明传入的列表中.

Prelude> :t ((^2) . foldl) (+) 0 …

所以我知道:

(.) = (f.g) x = f (g x)

它的类型是(B-> C) - >(A-> B) - > A-> C但是怎么样:

(.)(.) = _? = _?

这是如何表示的？我想到了:

(.)(.) = (f.g)(f.g)x = f(g(f(g x))) // this
(.)(.) = (f.g.h)x = f(g(h x)) // or this

但就我试图获得它的类型而言,GHCi告诉我的不正确.那么什么都是"_？"

另外 - 函数/运算符$做什么？

在我的代码中,我需要(Int, Int)按第二个元素的值对s 列表进行排序.

这很容易做到sorted = sortBy (\(_,a) (_,b) -> compare a b) listOfPairs,但我讨厌像这样写lambda,我需要在我的代码中的几个地方使用相同的lambda.

所以我试着创建两个有用的函数,我最终会在很多地方使用如下(我在前奏中找不到它们):

-- apply a function of one argument to two different arguments and return a pair
fBoth :: (a -> b) -> a -> a -> (b,b)
fBoth f a b = (f a, f b)

-- pass elements of a pair to a function of two arguments
expandPair :: (a -> b -> c) -> (a,b) -> c
expandPair f (a,b) = …

我正在努力解决Haskell中的Project Euler问题.我已经得到了下面的问题3的解决方案,我已经在小数字上进行了测试并且它可以正常工作,但是由于通过首先导出所有素数数字来实现蛮力,所以对于较大的数字它是指数级慢的.

-- Project Euler 3

module Main 
    where

import System.IO
import Data.List

main = do
    hSetBuffering stdin LineBuffering
    putStrLn "This program returns the prime factors of a given integer"
    putStrLn "Please enter a number"
    nums <- getPrimes
    putStrLn "The prime factors are: "
    print (sort nums)


getPrimes = do
    userNum <- getLine
    let n = read userNum :: Int
    let xs = [2..n]
    return $ getFactors n (primeGen xs)

--primeGen :: (Integral a) => [a] -> [a]
primeGen [] …

是否有某种形式的内置/术语我不知道它有点但不同的"组成"两个'a -> unit功能产生一个单一的功能; 例如:

let project event =
    event |> logDirections
    event |> stashDirections
let dispatch (batch:EncodedEventBatch) =
    batch.chooseOfUnion () |> Seq.iter project

可能成为:

let project = logDirections FOLLOWEDBY stashDirections
let dispatch (batch:EncodedEventBatch) =
    batch.chooseOfUnion () |> Seq.iter project

然后:

let dispatch (batch:EncodedEventBatch) =
    batch.chooseOfUnion () |> Seq.iter (logDirections FOLLOWEDBY stashDirections)

我想有人可能会比较它tee(如FSFFAP的铁路导向编程系列中提到的那样).

(它需要将相同的arg传递给两者并且我正在寻求按顺序运行它们而没有任何异常处理技巧问题等)

(我知道我可以做,let project fs arg = fs |> Seq.iter (fun f -> f arg)但我想知道是否有内置的和/或某种形式的组合库我不知道)

我有几个带签名的过滤功能'a -> bool.我想创建一个组合过滤器,AND是不同的过滤器.我知道我可以这样做:

let fCombined x =
    f1 x 
    && f2 x
    && f3 x

有没有更简洁的方法来直接组合函数而不完全应用它们(例如,x从定义中删除fCombined)？

(我知道还有其他不使用的方法bool,例如使用'a -> 'a option函数并使用它们编写它们Option.bind,但这几乎不简洁.)

在榆树中，如果我有匿名功能

(\f x -> f x)

我可以简化为

(<|)

对于参数为另一个函数的参数的两参数函数，可以这样做吗？

(\x y -> f x y |> g)

我以为我可以用

(f |> g)

但是编译器抱怨类型。

具体来说，在我的update函数的一种情况下，我有类似以下内容：

let
  msgNames = [Foo, Bar]

  values = ["f", "b"] // These values are actually derived
                      // by a more complicated operation

  model_ = List.map2 (<|) msgNames values
               |> List.foldl (\msg mod -> update msg mod |> Tuple.first)
                      model
in
  ( model_, Cmd.none )

我试图简化匿名函数参数List.foldl喜欢的东西(update |> Tuple.first)，但我从编译器以下错误：

The right side of (|>) …

假设,在Haskell中,我有一堆函数都依赖于相同的参数类型:

f :: Par -> a -> b
g :: Par -> b -> c

由于我正在编写更多依赖于此参数类型的函数,我可以执行类似的操作

h :: Par -> a -> c
h par = myg . myf
    where myf = f par
          myg = g par

但是我不得不写这些where线.问题是:这可以避免吗？

[编辑:我试图提供一个最小的例子来说明问题,但显然这个例子太小而无法说明我想要的东西.在实际问题中,h当然不仅仅是f和g的组成.所以这是一些实际的代码:

有功能

apply :: ChamberLattice -> ChLatword -> ChLatWord
reduce :: ChamberLattice -> ChLatWord -> ChLatWord

我正在定义一个函数

chaseTurn :: ChamberLattice -> Turn -> Parity -> ChLatWord -> ChLatWord
chaseTurn cl Straight _ xs = xs
chaseTurn cl t parity …

Is it possible to orElse compose two PartialFunctions when the first function has case _ => wildcard pattern that matches anything thus in effect being a total function.

For example, given

val pf1: PartialFunction[Int, String] = {
  case 1 => "foo"
  case 2 => "bar"
  case _ => "wildcard"
}

val pf2: PartialFunction[Int, String] = {
  case 3 => "baz"
  case _ => "wildcard"
}

then, out-of-the-box

(pf1 orElse pf2)(3)

outputs wildcard. However, assuming we cannot modify pf1 …