标签: combinators

我需要一些帮助来设计一个monadic数据类型,我似乎无法绕过这个想法,但我肯定知道我想要什么.只有类型检查器似乎需要一些说服力.

我想要的是一些Primitive可以是monad的数据类型.它的功能基本上是绘制图元,我希望能够将它们和组合组合成基元,就像Parser库中的类型一样parsec.但实际绘图必须用IOmonad 完成.

顺便说一句,我也有这样一个类Drawable a:

class Drawable a where
    draw :: (MonadIO m) => Pos -> a -> m ()

我希望每个原始人都可以绘制.感谢任何意见.

我一直认为这两个定义都是将其他函数作为参数的函数.我理解每个领域都不同,但它们的定义特征是什么？

我想在Haskell中写这样的东西:

length . nub . intersect

但它不起作用.

*Main Data.List> :t intersect
intersect :: Eq a => [a] -> [a] -> [a]
*Main Data.List> :t nub
nub :: Eq a => [a] -> [a]
*Main Data.List> :t length
length :: [a] -> Int

根据上式,我的理解是,intersect返回类型[a],并捐赠给nub,这恰恰是一个类型的[a],然后也返回一个类型[a]来length,最后返回应该是一个Int.它出什么问题了？

我在功能构成和类型方面遇到了一些麻烦.我想撰写filter(返回一个列表)len,其中列表作为参数(技术上是一个,Foldable但我在这里简化).查看类型一切都如预期:

> :t length
length :: Foldable t => t a -> Int

> :t filter
filter :: (a -> Bool) -> [a] -> [a]

所以现在我期待的类型(len . filter)是

(length . filter) :: (a -> Bool) -> [a] -> Int

而实际上是

> :t (length . filter)
(length . filter) :: Foldable ((->) [a]) => (a -> Bool) -> Int

所以我似乎失去了一些论点.是否Foldable以某种方式包含在要求中我不理解？

请注意,如果我进行部分应用,一切都按预期工作:

> let myFilter = filter odd
> :t myFilter
myFilter …

我将使用组合器,而不是来自F#的List模块的/ while循环,递归或定义的库函数,除了constructors ::和[]

理想情况下,我想实现地图

我正在尝试编写一个名为llength的函数,它返回子列表的长度列表.例如llength [[1; 2; 3]; [1; 2]; [1; 2; 3]]应返回[3; 2,3].我还有函数长度,返回列表的长度.

let Tuple f = fun a b -> f (a, b)
let length l : int =
    List.fold (Tuple (fst >> (+) 1)) 0 l

目前有

let llength l : int list =
    List.map (length inner list) list

不知道我应该如何尝试使用我的约束来访问我的子列表,我应该在每个子列表中使用我的其他方法吗？非常感谢任何帮助,谢谢!

我正在寻找一种方法来组合两个（或多个）约束，这样就Combine c1 c2 a意味着c1 a和c2 a，反之亦然。当约束用作输入时，这可能很有用：

data HList constraint where
  Empty :: HList constraint
  (:*:) :: constraint a => a -> HList constraint -> HList constraint

其中show和negate可以应用于 hlist 类型的元素HList (Combine Show Num)。

有了这些要求，type Combine c1 c2 a = (c1 a, c2 a)就不行了，因为类型同义词必须饱和。我也尝试声明Combine为一个类，但不能暗示这一点(Combine c1 c2 a) => c1 a或c2 a：

class (c1 a, c2 a) => Combine c1 c2 a
instance …

我是做从练习YAHT的递归数据类型部分时,发现写的listFoldr功能有点挑战性(主要是因为我真的不明白之间的差别foldl,并foldr在第一次).当我终于意识到foldr函数是如何工作的时候,我决定简单地交换函数参数就可以将我的listFoldl函数更改为listFoldr函数了:

listFoldl f i [] = i
listFoldl f i (x:xs) = listFoldl f (f i x) xs

listFoldr f i [] = i
listFoldr f i (x:xs) = listFoldr f (f x i) xs

这似乎工作(我做了比这更多的测试):

Main> foldr (-) 4 [1, 2, 3]
-2
Main> listFoldr (-) 4 [1, 2, 3]
-2

但是练习的解决方案与我的不同.他们listFoldl与我的完全一样,但看看他们listFoldr:

listFoldr f i [] = i
listFoldr …

--  eg. myzip [’a’, ’b’, ’c’] [1, 2, 3, 4] -> [(’a’, 1), (’b’, 2), (’c’, 3)]
myzip :: Ord a => [a] -> [a] -> [(a,a)]
myzip list1 list2 = [(x,y) |  [x, _] <-list1, [y,_] <-list2 ] 

我收到此错误消息:

 Occurs check: cannot construct the infinite type: a = [a]
    When generalising the type(s) for `myzip'
Failed, modules loaded: none.

我有数据类型:

data SidesType = Sides Int Int Int deriving (Show)

我需要一个函数来获取SidesType列表并从中删除重复项.

*Main> let a = [Sides 3 4 5,Sides 3 4 5,Sides 5 12 13,Sides 6 8 10,Sides 6 8 10,Sides 8 15 17,Sides 9 12 15,Sides 5 12 13,Sides 9 12 15,Sides 12 16 20,Sides 8 15 17,Sides 15 20 25,Sides 12 16 20,Sides 15 20 25]
*Main> removeDuplicateFromList [] a
[Sides 3 4 5,Sides 5 12 13,Sides 6 8 10,Sides 6 8 10,Sides 8 15 17,Sides 9 12 …

这是代码(也在这里):

#lang racket
(define poorY
  ((lambda length
    (lambda (ls)
      (cond
        [(null? ls) 0]
        [else (add1 ((length length) (cdr ls)))])))
  (lambda length
    (lambda (ls)
      (cond
        [(null? ls) 0]
        [else (add1 ((length length) (cdr ls)))])))))

当我运行它:

> (poorY '(9 7 8))
. . application: not a procedure;
 expected a procedure that can be applied to arguments
  given: '(#<procedure>)
  arguments...:
   '(#<procedure>)

屏幕截图如下所示:

我正在使用DrRacket作为代表.代码有什么问题？

我一直在尝试采用一些简单的功能，并将其转换为无点样式进行练习。我开始是这样的：

zipSorted x y = (zip . sort) y $ sort x --zipSorted(x, y) = zip(sort(y), sort(x))

并最终将其转换为

zipSorted = flip (zip . sort) . sort

（我不确定这是否是最好的方法，但确实可行）

现在，我试图不让它依赖于进一步降低这种表达zip，并sort在所有。换句话说，我正在寻找此功能：（如果我的词汇没有误，我认为它是一个组合器）

P(f, g, x, y) = f(g(y), g(x))

sort出现两次但只传递一次的事实提示我应该使用应用函子运算符，<*>但由于某种原因我不知道怎么做。

根据我的理解，(f <*> g)(x) = f(x, g(x))因此，我尝试以这种形式重新编写第一个无点表达式：

flip (zip . sort) . sort
(.) (flip $ zip . sort) sort
(flip (.)) sort $ flip (zip . sort)
(flip (.)) sort $ flip $ (zip .) …

import Data.List.Split
import Data.List(nub, groupBy)

z = splitOn "+" "x^2+2*x^3+x^2"

y = map (splitOn "*") z

x = map head y

toInt :: [String] -> [Int]
toInt = map read

u1 = filter ((< 2) . length) y
u2 = filter ((> 1) . length) y

v = map ("1" :) u1

q = u2 ++ v
q2 = zip toInt(map head q) (map last q)
q6 = groupBy nub(map tail q) q
q3 = map tail q
q5 = …

我一直试图用这种类型的签名组合一个组合器:

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

我已经通过Data.Aviary.Birds和我能找到的所有默认编程帮助网站,但无济于事.此外,如果有一个通用的算法来做这些,将非常感激,但不是必要的.