标签: pointfree

不久前,我问了一个关于$的问题,并得到了有用的答案 - 事实上,我以为我明白了如何使用它.

看来我错了:(

此示例显示在教程中:

instance Monad [] where
   xs >>= f = concat . map f $ xs

我不能为我的生活看到为什么在那里使用$; ghci也没有帮助我,因为我在那里进行的测试似乎表明与简单省略$的版本等效.有人可以为我澄清一下吗？

你能解释一下表达式的含义((.).(.))吗？据我所知(.)有类型(b - > c) - >(a - > b) - > a - > c.

玩无点风格的 javascript以获得乐趣.

假设我正在编写视频游戏"暗黑破坏神",我正在使用像这样的复杂嵌套类型对敌人进行建模,但更深入,更复杂:

{ name: "badguy1", stats: { health: 10: strength: 42 }, pos: {x: 100, y: 101 } }

所以我列出了我所有的敌人.我想对某个半径范围内的所有敌人造成伤害

function isInRange(radius, point) { return point.x^2 + point.y^2 >= radius^2; }
function fireDamage(health) { return health - 10; }    
var newEnemies = enemies.filter(isInRange).map(fireDamage);

这当然不是类型检查 - 我的组合器采用原语,所以我需要映射和过滤"另一个级别".我不想模糊过滤器/地图业务逻辑管道.我知道镜头可以帮助我,但我可以说我在浏览器中,因为这对于可变结构来说当然是微不足道的.我该怎么做？

您好如何在编写方法时强制执行GHC 类似函数Data.Text.read或=~运算符的类型Text.Regex.Posix？

例:
a=["1.22","3.33","5.55"]

没有点免费:
b= map (\x-> read x ::Double) a

如何read使用无点表示法强制执行类型？

b=map read::Double a 或
b= map (read . f1 .f2 .f3... . fn )::Double a (构成方法时)
,其中f1 , f2 ...fn一些方法

或者更好的是,read当它属于一系列方法时,如何指定类型,但不是在链的末尾!:
b=map (f2 . read . f1 ) a

我一直在学习Factor和J语言来试验无点编程.这些语言的基本机制似乎很清楚,但是如何理解如何进行算法设计是一项挑战.

对我来说,一个特殊的混淆源是如何构造代码以便很容易地尝试不同的参数.通过这个,我的意思是Mathematica和Matlab如此擅长的事情; 你设置了一个算法然后操纵变量并观察发生了什么.

没有显式变量,你怎么做？也许我在想这一切都错了.我应该如何在无点编程中实现这一点？

所以我一直听到很多关于点自由编程的知识,我决定做一个小实验来测试我对它的掌握程度.这涉及采用有针对性的函数来计算数字的阶乘并将其转换为无点形式.我设法做到了,但是无点结果的可读性远远低于尖锐的结果.

-- pointed
fact 0 = 1
fact n = n * (fact (n-1))
-- point free
fact' = foldr1 (*) . takeWhile ((<) 0) . iterate (flip (-) 1)

我是否遗漏了指向自由符号所必需的东西,或者这是否可以像某些转换那样可读？对我来说,似乎fact函数的很大一部分是零上的模式匹配,实际上,模式匹配是我喜欢Haskell的最大原因之一.然而,无点符号似乎完全不允许这一点,以及其他一些非常有用的东西,如列表推导.

好吧,事实证明我在程序代码中定义了这个函数:

st_zipOp :: (a -> a -> a) -> Stream a -> Stream a -> Stream a
st_zipOp f xs ys = St.foldr (\x r -> st_map (f x) r) xs ys

它做了它似乎做的事情.它Stream a使用类型的内部运算符拉链(应用运算符几次,是)两个类型的元素,这是类似列表的类型a.定义非常简单.

一旦我以这种方式定义了函数,我就尝试了另一个版本:

st_zipOp :: (a -> a -> a) -> Stream a -> Stream a -> Stream a
st_zipOp = St.foldr . (st_map .)

据我所知,这与上面的定义完全相同.它只是前一个定义的无点版本.

但是,我想检查是否有任何性能变化,我发现,实际上,无点版本使程序运行稍差(内存和时间).

为什么会这样？如果有必要,我可以编写一个再现此行为的测试程序.

我正在编译,-O2如果这有所作为.

简单的测试案例

我写了下面的代码,试图重现上面解释的行为.我这次使用了列表,并且性能的变化不太明显,但仍然存在.这是代码:

opEvery :: (a -> a -> a) -> [a] …

在haskell.org上,我遇到了这个自由风格的功能,被称为"猫头鹰".

((.)$(.))

它的类型签名是 (a -> b -> c) -> a -> (a1 -> b) -> a1 -> c.

这相当于 f a b c d = a b (c d) 并且显然是 ((.)$(.)) (==) 1 (1+) 0 回报True.

所以我的问题是:

1. 什么是a1在类型签名是什么意思？它与a？有关吗？
2. 是(==)某种函数相等运算符？因为0 (==) 0在GHCi中抛出错误.
3. 1 (1+) 0在这种情况下意味着什么？我不知道这甚至是一个有效的表达方式.
4. 为什么表达式会返回True？

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

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 - …

尝试使用过滤器提取长度为k的子集。不确定如何处理？该列表包含100个元素。

subsets :: [a] -> [[a]]
subsets [] = [[]]
subsets (x:xs) = [zs | ys <- subsets xs, zs <- [ys, (x:ys)]]

如果我使用过滤器，这就是我的想法：

filter (length(3)) subsets [1,2,3,4,5]

但是我可能错了。如果有其他方法而不是过滤器？我是Haskell的新手，所以不确定。