我是haskell编程新手,我想知道为什么我会出错。
Non type-variable argument in the constraint: Eq Int
(Use FlexibleContexts to permit this)
当我试图定义这样的函数时
union :: (Eq (Int)) => [Int] -> [Int] -> [Int]
给定Haskell函数:
head . filter fst
现在的问题是如何手工查找“手动”类型。如果我让Haskell告诉我我的类型:
head . filter fst :: [(Bool, b)] -> (Bool, b)
但是,我想了解这是如何工作的,只使用定义如下的已使用函数的签名:
head :: [a] -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
filter :: (a -> Bool) -> [a] -> [a]
fst :: (a, b) -> a
编辑:这么多很
我需要创建一个Haskell函数,它有一个泛型输入,但输出一个布尔值,这取决于泛型是否匹配某些数字/字符,如下所示:
checkFunct :: a -> Bool
checkFunct x = (elem x ['a','b','c'])
这是怎么回事,因为你不能把Char和泛型进行比较。我已经找了很长时间了,而且我是Haskell的新手,所以我不知道如何修复它。注意:如果特别说明了输入必须是->布尔值
例如,这段代码可以完美地工作:
checkFunct :: Char -> String
p x = elem x [
见以下两个问题:
--I don't want any defaulting. For example, I don't want
--a general Num to convert to Double deep within my codebase.
--I want to keep my codebase as general as possible.
--Only in main, where I actually call my pure functions,
--do I want to specify an actual, concrete type.
defau
我正在用液体haskell做一些实验,看看我能用它做什么样的整洁的事情,我撞到了一点墙。基本思想是,我有一些函数需要一个访问令牌,该令牌在一定时间内过期。我试图了解如何使用液态haskell来确保在将令牌传递给我的函数之前检查它的有效性。我在下面创建了一个最低限度的工作版本,这说明了我的问题。当我在这个文件上运行液体时,我会得到以下错误:
/tmp/liquidTest.hs:18:17-42: Error: Liquid Type Mismatch
18 | isExpired tok = currTime >= expiration tok
获取以下错误:
• No instance for (Num [Int]) arising from the literal ‘5’
• In the second argument of ‘(==)’, namely ‘5’
In the expression: x == 5
In the expression: if x == 5 then True else False
尝试加载haskell函数时:
listContainsFive :: [Int] -> Bool
listContainsFive [] = error "empty list"
listCont
在Haskell的类型系统的表面上,运行如下:
Prelude> e = []
Prelude> ec = tail "a"
Prelude> en = tail [1]
Prelude> :t e
e :: [a]
Prelude> :t ec
ec :: [Char]
Prelude> :t en
en :: Num a => [a]
Prelude> en == e
True
Prelude> ec == e
True
尽管en和ec有不同的类型,但它们都在== e上测试True。我说“不知为什么”并不是因为我感到惊讶
完全是Haskell菜鸟。我有一个简单的函数和一个main。我不知道这个错误是什么意思:
Couldn't match expected type `IO t0' with actual type `Bool'
In the expression: main
When checking the type of the function `main'
编译代码时:
is_instructor :: String -> Bool
is_instructor "Jeremy Erickson" = True
is_instructor x = F
所以我做了一个关于Haskell的测试,其中一个问题是:
让函数成为
lolo g x = ys
where ys = [x] ++ filter (curry g x) ys
然后确定名为lolo的函数的类型。选项包括:
a) (a,b) -> Bool -> b -> [(a,b)]
b) (b -> b -> b) -> Bool -> [b]
c) ((b,b) -> Bool) -> b -> [b]
d) (a -> b -> Bool) -> b -> [c]
有人能解释一下是哪一个吗
在搜索雷蒙德·斯穆里安“模仿一只知更鸟”的信息时,我偶然发现了。我认为这是一个有趣的想法,并决定用这些组合子实现从第24章到“模仿一只知更鸟”中的“会算术的鸟”。我已经定义了真理、虚假、后继、前任和零检查组合子,再加上将组合布尔转换为Haskell布尔的函数,反之亦然。但是,当我试图创建一个函数,它接受一个组合数并返回一个整数时,我总是会遇到一些问题。我想知道如何使这个函数工作。到目前为止,我得到的是:
-- | The first 7 combinators below are from Stephen Tetley's Data.Aviary.Birds
-- | (http://
我试图理解函数的Haskell类型变量。我写了一个函数:
applyTwice f x = f(f x)
我试图理解这个函数的类型变量,所以我做了一个:t applyTwice。Haskell就是这样解释类型的:
applyTwice :: (t -> t) -> t -> t
然后我创建了另一个函数:
applyOnce f x = f x
这一次:t Haskell返回
applyOnce :: (t1 -> t) -> t1 -> t
我的问题是
我们如何读取/理解这些函数的接收和返回?
这是给applyTwice的。如果他们说->的左边
我试图理解Haskell中的RankNTypes,并找到了以下示例:
check :: Eq b => (forall a. [a] -> b) -> [c] -> [d] -> Bool
check f l1 l2 = f l1 == f l2
(如果我的理解是正确的,这相当于check :: forall b c d. Eq b => (forall a. [a] -> b) -> [c] -> [d] -> Bool。)
好吧,到目前为止还不错。现在,如果移除显式forall a,GHC将产生以下错误:
Could not de
以下假设的Haskell代码到底有什么错误?当我在我的大脑中编译它时,它应该输出"1“。
foo :: forall a. forall b. forall c. (a -> b) -> c -> Integer -> b
foo f x n = if n > 0 then f True else f x
bar :: forall a. a -> Integer
bar x = 1
main = do
putStrLn (show (foo bar 1 2))
GHC抱怨:
$ ghc -XRankNTypes -XScopedTyp
另外,由于您的帮助,我在Haskell中完成了一些步骤来理解类型系统。我仍然不明白的是这样的建筑:
chk :: Eq b => (a -> b) -> a -> b -> Bool
为什么类约束仅限于'b',而不能比较不同的类型?
a/b不是用来表示不同类型的吗?如果我搞错了,你能给我看个这样的函数吗?
我一直在阅读关于Haskell的文章,我很难理解函数定义是如何用这种语言处理的。
假设我正在定义一个sum函数:
let sum x y = x + y
如果我查询Haskell的类型
:t sum
我得到了
sum :: (Num a) => a -> a -> a
=>操作符是什么意思?它与lambda表达式有关吗?这就是在=>操作符后面的信号是C#中的一个。
a -> a -> a是什么意思?通过对我已经尝试过的许多不同函数的观察,似乎初始的a -> a是参数,而最终的-> a是和函数的结果。如果这是正确的,为什么不像(a,
有人能解释Haskell中回文的这个功能是如何工作的吗?
palindrome :: Eq a => [a] -> Bool
palindrome = reverse >>= (==)
-- type declarations
reverse :: [a] -> [a]
>>= :: Monad m => m a -> (a -> m b) -> m b
(reverse >>=) :: ([a] -> [a] -> b) -> [a] -> b
(==) :: Eq a => a -
我是haskell的新手,我读过一些关于类型签名的东西,但有几件事我不明白。
下面是我看到的代码:
--mult applies product
mult :: Num a => [a] -> a
mult = foldr (*) 1
--posList filters positive numbers out
posList :: (Ord a, Num a) => [a] -> [a]
posList = filter (>0)
--trueList determines whether all of the members of a list ar
在Haskell的导论中,“学习Haskell for Great Good”,作者定义了一个函数,applyTwice,它两次将函数f应用到参数x中,以说明函数范例的核心是高阶功能。
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
到目前为止,我发现Haskell的类型声明很清楚,但是这个特殊的例子让我感到困惑。我认为这是一个更好地理解类型声明的机会。
作者指出这个构造“表示第一个参数是一个函数,它接受并返回相同的东西,第二个参数也是该类型的,返回值也是相同类型的。”()。
此类型声明意味着什么?为什么
嗨,我是haskell的新手,我在函数定义方面遇到了困难。在作业中,我需要使用这个函数
insort :: [a] -> (a -> a -> Bool) -> [a]
insort [] _ = []
insort (x : xs) f = ins x (insort xs f)
where
ins x [] = [x]
ins x (y : ys) = if (f x y)
我正在尝试理解Haskell中的编程约定和规则。我发现令人困惑或难以理解的一件事是括号()的使用。谁能给我解释一下在all函数的情况下它是做什么的?
all :: (a -> Bool) -> [a] -> Bool
all p xs = and [ p x | x <- xs ]
据我所知,函数的类型显示了类型约束、输入和输出。就不会有
all :: [a] -> Bool
够了吗?
在试图理解Haskell如何确定函数类型时,我有点困惑。下面是一个示例:
boolFcn x y = x/=3 && y/=4
当我检查上述函数的类型时,它给出了结果:
(Num a1, Num a, Eq a1, Eq a) => a -> a1 -> Bool
下面是另一个例子:
triangles = [ (a,b,c) | c <- [1..10], b <- [1..10], a <- [1..10] ]
以及:t在triangles上的应用结果如下:
(Num t2, Num t1, Num t, Enum t2, Enum
根据GHC的文件,考虑到以下声明:
data Foo = forall a. MkFoo a (a -> Bool)
| Nil
然后
MkFoo :: forall a. a -> (a -> Bool) -> Foo
是(几乎)同构于以下伪Haskell声明
MkFoo :: (exists a . (a, a -> Bool)) -> Foo
因此,不需要单独的"Exist“关键字。因为:
Haskell程序员可以安全地想到上面给出的普通通用量化类型。
但我不知道那是什么意思。有人能解释一下为什么我们可以用通用量词
考虑以下多行字符串S
apple
banana berry
cantelope
我正在尝试编写/定位Haskell函数,我将在本文中调用这些函数,or-match和and-match。下面是一些他们应该做的事情的例子:
or-match S ("apple","berry")
{- should return the two line string:
apple
banana berry
-}
and-match S ("apple", "berry") --should return the empty string, or
我在Haskell学习一些基本的功能构图,当我在玩的时候,我意识到了一些我无法真正解释的东西。当我使用以下代码块时,编译器似乎对此很满意,并且运行良好:
doSomeX x = if x==7 then True else False
doSomeY (x,y) = x+y+1
doSomeXY = doSomeX.doSomeY
但是,当我将doSomeY分解为两个args而不是一对时,即:
doSomeX x = if x==7 then True else False
doSomeY x y = x+y+1
doSomeXY = doSomeX.doSomeY
我得到了以下错误:
No
是不是每个类都不是Haskell中的一个类型:
Prelude> :t max
max :: Ord a => a -> a -> a
Prelude> :t Ord
<interactive>:1:1: Not in scope: data constructor ‘Ord’
Prelude>
为什么这不打印Ord类型签名?
我当时正在Haskell上阅读页面,我仍然不明白如何以及为什么应该使用它们。作者举了一个令人振奋的例子:
data T a where
D1 :: Int -> T String
D2 :: T Bool
D3 :: (a,a) -> T [a]
这段代码到底是做什么的,为什么它有用?
如果这个问题有点模糊,也许相关的问题是:GADT是否可以用于实现成员函数?
我是一个Haskell新手,试图把我的头放在函数中的类型绑定以及Haskell如何执行它上。例如,即使fst函数的类型是fst :: (a, b) -> a,编译器也不会抱怨fst'函数。但是编译器会抱怨函数elem'的类型绑定。
fst' :: (a,a) -> a
fst' s = fst s
elem' :: (Eq a, Eq b) => a -> [b] -> Bool
elem' x xs = elem x xs
对于Haskell 98 decls,整个数据类型必须是newtype或data。但数据系列可以混合使用newtype instance、data instance。这是否意味着newtype是数据构造函数的属性,而不是数据类型的属性?有没有可能有Haskell这样的东西:
data Foo a = MkFoo1 Int a
| MkFoo2 Bool a
| newtype MkFoo3 a
我知道我不能写下面的内容,但是为什么/哪里出错了?:
data family Bar a
newtype instance Bar (Maybe Int)
我目前正试图把我的头脑围绕着打字机和实例,但我还不太明白它们的意义。到目前为止,我对这个问题有两个问题:
1)当函数使用某个类型类的某个函数时,为什么函数签名中需要有一个类型类。示例:
f :: (Eq a) => a -> a -> Bool
f a b = a == b
为什么要把(Eq a)放在签名里。如果==不是为a定义的,那么为什么不直接在遇到a == b时抛出错误呢?在前面声明类型类有什么意义?
2)类型类与函数重载有何关系?
这样做是不可能的:
data A = A
data B = B
f :: A -> A
f a = a
f :: B ->
我正在学习Haskell,我遇到了一种情况,在这种情况下,我不完全确定发生了什么。
我正在做一个更大的项目,并且一直试图“简化”我的代码。我已经学会了功能构图,我想我很了解它。然而,在突破极限的同时,我遇到了一个我不知道该如何解释的情况。
经过几个小时的摆弄,我把它归结为:
foo1 x y z = x == (y && z)
foo2 x y z = (x ==) . (&&) y z -- Error
foo3 x y = (x ==) . (&&) y
foo4 x = (x ==) . (&&)