在Haskell中是否有可能匹配元组,但不知道元组的维度?我想创建一个针对任何元组的函数,第一个元素是A,如下所示:
data A = A Int
test args@(A a,..) = a
我知道有Data.Tuple.Select模块,我可以这样使用它:
test args = case sel1 args of
A a -> a
...
但是,这是唯一的方法,还是Haskell有一些默认机制来匹配任何维度元组?
Haskell库包含一个类型类,它同时定义了和函数。
class
(FunctorWithIndex i t, FoldableWithIndex i t, Traversable t)
=> TraversableWithIndex i t | t -> i where
itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)
itraversed :: IndexedTraversal i (t a) (t b) a b
IndexedTraversal像
我正在尝试为多种类型创建一个多态镜头解密(没有模板haskell)。
module Sample where
import Control.Lens
data A = A {_value:: Int}
data B = B {_value:: Int}
data C = C {_value:: String}
value = lens _value (\i x -> i{_value=x}) -- <<< ERROR
但我得到以下错误:
Ambiguous occurrence ‘_value’
It could refer to either the field ‘_
我有两种数据类型,A和B,我将它们定义为:
data A = A { aFoo :: Int, aBar :: String }
data B = B { bFoo :: Int, bBar :: String, bBaz :: Float }
现在我需要创建一个A和B的异构列表,因此我将sum类型C定义为:
data C = CA A | CB B
我现在要定义函数
cFoo :: C -> Int
cBar :: C -> String
这可以通过模式匹配来实现。
cFoo (CA a) = aFoo a
cFoo (CB b) = bFoo b
cBar (CA a) =
我想根据记录中的特定值执行一种排序。因此,我想把一个镜头传递到一个lensSort函数中,但是我一直无法使它工作。
理想情况下,我可以做这样的事情
lensSort :: HasLens a => Lens' a b -> a -> a -> -> Ordering
lensSort lens x y | x ^. lens > y ^. lens = GT
| x ^. lens < y ^. lens = LT
| otherwise = GT
可以用这样的方式
我想做一些非常简单的事情;生成一个wreq响应并将内容打印到终端。
语言如下:{-# main.hs OverloadedStrings #-}
module Main where
import Network.Wreq
import qualified Data.ByteString.Char8 as C
main :: IO ()
main = do
r <- get "http://httpbin.org/get"
putStrLn (C.unpack r)
为什么?因为r似乎是一个字节串,所以它应该是不可打包的。
Prelude> import
我的问题与Haskell上的一个程序设计有关。但我想集中在一个具体的用例上。
我定义了一个数据类型(例如Foo),并通过模式匹配在函数(例如f)中使用它。后来,我意识到类型(Foo)需要一些额外的字段来支持新功能。但是,添加该字段会改变该类型的使用方式;即,依赖于该类型的现有函数可能会受到影响。向现有代码添加新功能,无论多么缺乏吸引力,都是很难避免的。我想知道Haskell语言级别的最佳实践是什么,以将此类修改的影响降至最低。
例如,现有代码为:
data Foo = Foo {
vv :: [Int]
}
f :: Foo -> Int
f (Foo v) = sum v
如果我
考虑以下Haskell代码:
import Control.Monad.State
test :: Int -> [(Int, Int)]
test = runStateT $ do
a <- lift [1..10]
modify (+a)
return a
main = print . test $ 10
这将产生以下输出:
[(1,11),(2,12),(3,13),(4,14),(5,15),(6,16),(7,17),(8,18),(9,19),(10,20)]
但是,我希望生成以下输出:
[(1,11),(2,13),(3,16),(4,20
在Haskell中,()类型有两个值,即()和底部。如果您有一个表达式e :: (),那么就没有必要实际检查它,因为它要么是e = (),要么是通过检查它来破坏本来没有崩溃的程序。
因此,我认为对()类型的值的操作可能不会检查值,也不会区分()和底部。
然而,这是非常不真实的:
▎λ ghci
GHCi, version 9.0.2: https://www.haskell.org/ghc/ :? for help
ghci> u = (undefined :: ())
ghci> show u
"*** Exception: Prelude.undefined
Call
我的职责如下:
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) -> .只有一个双射函数,但我也不知道
我能够完美地执行以下代码
myLast :: [a] -> a
myLast [] = error "Can't call myLast on an empty list!"
myLast (x:_) = x
但是我得到了以下代码的这个错误Couldn't match expected type `a' with actual type `[a]'. `a' is a rigid type variable bound by the type signature for myLast :: [a] -> a:
myLast :
考虑下面的Haskell代码。
data Keypress = Keypress Int Char
getSeq :: Keypress -> [Char]
getSeq (Keypress i c) = replicate i c
有什么方法可以用无点形式编写getSeq 吗?
getSeq的定义非常类似于它的模式匹配,因此似乎有一些方法可以使用赛跑或单数,或者某种东西来避免指定i和c参数。然而,由于模式匹配,并没有解析getSeq的无点输出。
有可能吗?
获取以下错误:
• 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
简单的例子:
{-# LANGUAGE TemplateHaskell #-}
import Language.Haskell.TH
import Control.Lens
data Point = P { _x :: Double, _y :: Double } deriving (Show)
$( makeLenses ''Point )
这就是我试图用命令式风格做的事情:
point.set( "x", g (point.get("x") ) )
目前,我尝试了这个实现:
mapF f p g = let v = g (p ^. f)
我对Haskell并不熟悉,我正在尝试编写一个函数,它包含一个列表并返回一个bool。
如果输入列表是仅由True组成的列表,则返回'a',否则返回False。
这是我最好的猜测:
f :: [a] -> Bool
f ('a':[]) = True
f (x:xs) = False
这无法编译并返回:
Couldn't match type `a' with `Char'
`a' is a rigid type variable bound by
the type signature for f ::
我刚开始学习Haskell,用了一本书“学习Haskell for Great Good”,并读完了第9章“输入和输出”。但是当我尝试一个例子时,我遇到了一些奇怪的问题,大致可以说是三个步骤。
1)本书中的示例代码是
finiteRandoms :: (RandomGen g, Random a, Num n) => n -> g -> ([a], g)
finiteRandoms 0 gen = ([], gen)
finiteRandoms n gen =
let (value, newGen) = random gen
(res
我对Haskell并不熟悉,我试图在基数10中得到一个数字的长度,所以我创建了length‘函数:
length' :: (Integral a) => a -> a
length' a = length $ show a
但是Haskell给出了“无法匹配类型”错误,因为length返回Int。我不明白为什么它会给我一个错误,因为它是一个积分的实例.
我在Haskell中定义了以下类型:
data AE = Num Float
| Add AE AE
| Sub AE AE
| Mult AE AE
| Div AE AE
deriving(Eq, Read, Show)
现在我如何解构它呢?具体来说,我应该如何完成一个函数,如下所示:
testFunct :: AE -> something
testFunct expression
| if type Num = do this
| if type Add = then do this
我刚开始学习haskell和模式匹配。我只是不明白它是如何实现的,[]和(x:_)的计算结果是不同的类型,这种模式的函数实现由于多态性而被识别,或者我错了,还有另一种使用的技术。
head' :: [a] -> a
head' [] = error "Can't call head on an empty list, dummy!"
head' (x:_) = x
或者让我们考虑这个模式匹配函数:
tell :: (Show a) => [a] -> String
tell [] = "The list i
我正在试着写一个Haskell追加函数...这就是我所拥有的:
myappend :: [a] -> [a] -> [a]
myappend [] x = x
myappend [x:xs] y = x : myappend xs y
但它给了我一个错误:发生检查:当泛化‘`myappend’的类型时,无法构造无限类型:a=a
所以,很明显它出了点问题,但我看不出来...我的append函数有什么问题?
我正在尝试用Haskell创建一个我认为非常直观的方法。我有一个列表的列表*,它是任意深度的。我想从列表中取出一个特定的原子,而不考虑递归的深度。这是我的努力:
type List = [Array]
data Array = Int | List
drill :: Array -> [Int] -> Array
drill xs (index:[]) = xs !! index
drill xs (index:is) = drill (xs !! index) is
但是,我在ghci中加载时收到以下内容:
drill.hs:5:23:
Couldn't match e
为了在Haskell的道路上取得先机,我选择了这本书的创作者之一Hudak。所以,我正在进行关于哈斯克尔的介绍。
我被困在试图理解以下声明:
从技术上讲,形式参数也是模式,但它们总是与值匹配。
从我对C这样的语言(或者广义地说是非函数式语言)的小而大的习惯来看,我可以形成形式参数是函数定义中的参数。因此,假设C中有一个类似于下面的函数:
int func_add(int a, int d)
然后,如果我是正确的,传递其他类型的值(如字符串)将是模式匹配的失败。因此,调用func_add作为func_add("trs", 5)是模式不匹配的一种情况。
由于极有可能出现错