如何在Haskell中使用curry和uncurry前置函数?
此外,为什么以下定义在加载时会抛出错误?
curry' :: ((a -> b) -> c) -> a -> b -> c
curry' f = \x y -> f (x, y)
uncurry' :: a -> b -> c -> ((a -> b) -> c)
uncurry' f = \(x,y) -> f x y
我试图理解函数的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的新手,我正试图通过编写一些代码来理解这种语言。我只熟悉ghci上非常简单的指令: head、tail、sum、(*)等--非常简单。
我想做的这个函数,是用来求解任意维数的向量的毕达哥拉斯定理。这看起来像这样:平方根(a^2 + b^2 + c^2 ...)
在ghci中,我可以在几行代码中完成以下操作,我正在尝试创建一个函数:
sq x = x*x
b = map sq [1,2,3]
a = sum b
x = sqrt b
当我这样做时,我会尝试包含许多种类的签名,目前我的函数看起来是这样的:
mod :: [Num a] => a
mod x = sqr
我正在查看Haskell的简介,其中包含以下示例:
data Tree a = Leaf a | Branch (Tree a) (Tree a)
它说,它本质上也定义了以下类型:
Branch :: Tree a -> Tree a -> Tree a
Leaf :: a -> Tree a
我理解叶子的定义是说它将一个a映射到一个Tree of a。但是我不明白分支的定义,我把它理解为“分支映射Tree of a到Tree of a到Tree of a,这听起来不正确。这是因
我正在尝试学习Haskell的基础知识,我很难理解为什么doubleMe类型声明会导致“非法运算符”错误,而addThree根本不会导致错误?
doubleMe :: Int -> Int -> Int
doubleMe x = x + x
addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z
我很感谢你的澄清。
在此之前,非常感谢您。
在面向对象的语言(例如Java和Python)中,我们可以从类中生成对象/实例。在Haskell中,我们可以从类型类中创建实例,例如:
data ShirtSize = S | M | L -- Here ShirtSize is a enum data-type
class MyEq a where
(==) :: a -> a -> Bool
instance MyEq ShirtSize where -- Here ShirtSize is an instance of the MyEq type-class
S == S = True
M ==
对于Haskell和实验来说,我遇到了一个问题,看起来我想在构造函数中使用警卫。我真正的实验涉及的更多一些,但可以归结为
data X a = Zero
| a==0 = Zero
| otherwise = Some a
我知道--这是错误的语法,特别是因为a是类型变量,而不是值变量,所以a==0是荒谬的。
背景是,Zero和Some 0的值在所有方面都是相等的,我甚至可以说是相同的。事实上,我从来不想构建一个Some 0,这应该被禁止,或者,按照上面起草的那样,在构造函数中悄然转换为Zero。
我认为在Haskell中有一个常见的成语。在Java中,我只需要使两个构造函数pri
我正在研究格雷厄姆·赫顿( Graham )在Haskell中的编程,第三章中的一个练习问:“类型是什么?”对于函数twice f x = f (f x)。
我想我理解为什么答案是twice :: (t -> t) -> t -> t。(编辑:我不明白为什么。见我对保罗的回答的评论。)然而,为了进行实验,我编写了另一个函数thrice f x = f (f (f x))。
我绝对不明白为什么thrice也有一种类型的thrice :: (t -> t) -> t -> t。
它们的工作方式符合我的预期(见下文),但我看不出这种类型的thrice有什么意义。
在Haskell中,显式声明函数的类型签名被认为是一个很好的实践,尽管它(通常)可以被推断出来。在OCaml中,这似乎是不可能的。
val add : int -> int -> int ;;
给了我一个错误。(虽然我可以制作只提供签名的type模块。)
我说的对吗?在OCaml中这是不可能的吗?
如果是,为什么?OCaml的类型系统似乎与Haskell并没有那么大的不同。
我开始学习Haskell,并在函数语法方面苦苦挣扎。我试图创建一个接收数字'e‘和'n’的函数,返回一个包含'n‘倍'e’的列表。
示例:repn 3 5将返回[3,3,3,3,3]
repn :: Int a => a -> a -> [a]
repn e n
| n >= 1 = (take n (repeat e))
| otherwise = []
但我发现了一个错误:
* Expected kind `* -> Constraint', but `Int' has kind `*'
我看过很多资料:在F#中声明类型定义似乎是不可能的:
' haskell type def:
myFunc :: int -> int
我想在F#中使用这种type-def风格--FSI很乐意向我回应:
fsi> let myType x = x +1;;
val myType : int -> int
我想明确说明F#中的类型定义签名,就像在Haskell中一样。有没有办法做到这一点?我想用F#写:
//invalid F#
myFunc : int -> int
myFunc x = x*2
我正在学习函数式语言的范例。所以我读过,虽然子类型多态性在OO语言中是典型的,但是参数多态性对于功能语言来说是典型的。
但我不知道功能语言中是否存在亚型多态性。我最熟悉的函数式语言是Haskell,我知道在Haskell中有很多类型的语言。
我一直认为类型类型有点类似于接口,而接口是子类型多态性。例如在这里:
data Foo a = Bar a | Baz String
deriving instance Eq a => Eq (Foo a)
Eq是定义(==)运算符的类型类型。这基本上就像一个Foo类实现了一个Eq接口。
所以我要问的是:这是否被认为是子类型(或子类型多态性)?
我是Haskell的新手,我想知道有没有人能帮我。
我有一个自定义数据类型的列表,如下所示:
type Title = String
type Manager = String
type Year = Int
type Fan = String
type Album = (Title, Manager, Year, [Fan])
我有一个预先制作好的静态专辑数据库
albumDatabase :: [Album]
albumDatabase = [(...)]
我有一个函数可以返回经理制作的所有专辑:
manAlbum :: String -> [Album] -> [Album]
我正在我的Mac上试用Haskell,令我惊讶的是,当我定义了一个函数时,我得到了一个错误:
Prelude System.IO> :set prompt "ghci> "
ghci> addMe :: Int -> Int -> Int
<interactive>:11:1: error:
Variable not in scope: addMe :: Int -> Int -> Int
ghci>
如何在ghci上定义函数?
我正在阅读一些关于monad的东西,没有Haskell的经验,并且与类型构造函数的概念相混淆。
monad是一个三重结构(M、unitM、bindM),由一个类型构造函数M和一对多态函数组成。
unitM ::A -> M a bindM ::m a -> (a -> M b) -> M b
在Java中:
public class M<T> {
static <T> M<T> unit(T a)
static <T,R> M<R> bind(M<T> a, Function
我目前正在阅读格雷厄姆·赫顿( Graham )的“haskell中的编程”(Programming in Haskell),并刚刚达到了运行和函数( composition.In )中的练习部分,有一项任务是从头开始实现咖喱函数,该功能已经存在于前奏模块中。
这是我的实现,但它不是working.Can,任何人都解释(我是函数式编程新手)为什么它不能工作
my_curry :: ((a ,b) -> c) -> (a -> b -> c)
my_curry origFunc = origFunc.combine
where
我正在阅读“Haskell编程从第一原则”(Haskell Programming from First Principles )一书,并看到了下面的代码片段。
Prelude> fifteen = 15
Prelude> :t fifteen
fifteen :: Num a => a
Prelude> fifteenInt = fifteen :: Int
Prelude> fifteenDouble = fifteen :: Double
Prelude> :t fifteenInt
fifteenInt :: Int
Prelude> :t f
我有一个函数,它接受3个函数,并将它们组合起来修改一个list参数。
例如,一个测试用例调用应该是:链init尾部反向"Haskell!"输出应该是lleksa
我尝试过用几种不同的方法来解决这个问题,包括使用map函数,但是我总是遇到关联问题。所以我照做了
chain :: Ord a => [a] -> a
chain f g h x = f.g.h$x
错误是Couldn't match expected type [t0 -> t1 -> t2 -> a0]
当我在GHCi中直接输入问题时,比如通过编写init.tail.rever
在“学习Haskell”中,给出了以下示例:
map ($ 3) [(4+), (10*), (^2), sqrt]
[7.0,30.0,9.0,1.7320508075688772]
不过,我不明白这是怎么回事。
函数的签名如下
Prelude> :info ($)
($) :: (a -> b) -> a -> b
Prelude> :t ($ 3)
($ 3) :: Num a => (a -> b) -> b
然而,->是一个左联想运算符,所以$ :: (a -> b) -> a -> b实际上是((($ ::
我的职责如下:
pen :: (a -> b) -> (b -> a) -> (b -> b) -> a -> a
pen conv rev app = rev . app . conv
其用途如下:
pen read show (\x -> x + 1) "5"
"6"
我对Haskell非常陌生,我想知道在Haskell标准库中是否存在这样的函数,以及它的名称,因为我在Hoogle上找不到它。
我还假设在没有(a -> b) -> (b -> a) -> .只有一个双射函数,但我也不知道
关于Haskell的类型系统,我有一个非常普遍的问题。我正在尝试熟悉它,我有以下功能:
getN :: Num a => a
getN = 5.0 :: Double
当我试图编译这段代码时,我得到了以下错误:
Couldn't match expected type `a' against inferred type `Double'
`a' is a rigid type variable bound by
the type signature for `getN' at Perlin.hs:15:12
In the expre
我正在浏览在线书籍(链接将直接带您到我的问题所涉及的部分)。
作者定义了二叉树数据类型,并展示了如何通过实现Data.Foldable函数使其成为可折叠类型(在foldMap中定义)的实例:
import Data.Monoid
import qualified Data.Foldable as F
data Tree a = Empty | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)
instance F.Foldable Tree where
foldMap f Empty = mempty
foldMap f
我刚开始学习Haskell,对我来说,奇怪的是带有多个参数的函数类型的语法。
考虑一个简单的例子:
(+) :: Num a => a -> a -> a
为什么我们这里需要所有的箭?写像Num Num Num -> Num这样的东西不是更有意义吗?
引擎盖下的原因是什么?我寻找这个问题,但找不到任何有用的东西。
例如,我有一个函数
function init(model: any, eventData: UserApplicationModel) : any
我希望避免将类型信息与函数源代码混为一谈。我尝试过(在同一个源文件中):
declare function init(model: any, eventData: UserApplicationModel) : any;
function init(model, eventData) {
// source code here
}
但我得到了error TS2384: Overload signatures must all be ambie
我不清楚如何用haskell编写函数签名,特别是使用Maybe。考虑:
f :: Maybe a -> Maybe a
f = \a -> a
main = print (f (Just 5))
这是可行的,但是为什么函数签名不能就这样呢?
f :: Maybe -> Maybe
因为f只接受Maybe类型并返回Maybe类型。
相关:如果我想让可能的类型更具体,成为一个Maybe Int,为什么这不起作用?
f :: Maybe Int a -> Maybe Int a
f = \a -> a
main = print (f (Just (Int 5)))
现在我正在了解Haskell,我遇到了一个问题:
函数f的类型应该是a->[a]->a。f的下列定义是不正确的,因为它们的类型都不同于a->[a]->a:
一.f x xs = xs ii。F x xs = x+1 iii。F x xs =x ++ xs iv。f (y:ys) =y
我的答案是:
i) f :: a -> a -> a
这是因为x或xs可以是任何值,而不是一个列表,因为它不包含':‘操作符。
ii) f :: Int -> a -> Int
这是因为x上使用了+运算符,这意味着x是Int类型的。
iii) f :
我觉得学习haskell的心理障碍之一是,data有时将函数定义为数据。
data Person = Person {
name :: String,
age :: Int
}
这是直观的,类似于其他语言。但在
newtype StateT s m a = StateT {
runStateT :: s -> m (a,s)
}
这基本上是将一个函数s->m (a,s)称为“数据”。
我很容易明白,在高阶函数中,“函数”确实是作为数据传递的。但是在类型定义中,使用函数来定义类型,这是相当令人惊讶的。
所以我的问题是:这会给Haskell型系统带来表现力吗?这一切背后的