创建Monoid的自定义列表ADT实例
Monoid是一种代数结构，它由一个集合和一个二元运算组成。在函数式编程中，Monoid常用于处理集合的聚合操作。自定义列表ADT（Abstract Data Type）实例是指通过定义一个自己的列表数据类型来实现Monoid。
自定义列表ADT实例可以通过以下步骤来创建：
- 首先，定义一个列表数据类型，可以使用面向对象编程语言中的类或者函数式编程语言中的代数数据类型（Algebraic Data Type）来实现。这个列表类型可以包含一个值和一个指向下一个列表节点的指针。
- 接下来，实现Monoid的二元运算。在列表ADT中，二元运算可以是列表的连接操作，将两个列表合并成一个新的列表。这个操作可以通过遍历第一个列表，将第二个列表的元素依次添加到第一个列表的末尾来实现。
- 定义一个空列表作为Monoid的单位元素。空列表表示没有任何元素的列表，将它与任何非空列表进行连接操作，结果都是非空列表本身。
- 最后，为列表ADT实例提供一些常用的操作方法，例如添加元素到列表、删除列表中的元素、获取列表的长度等。
这样，我们就创建了一个自定义列表ADT实例，并且实现了Monoid的二元运算和单位元素。这个自定义列表ADT实例可以用于处理集合的聚合操作，例如将多个列表合并成一个列表。
在腾讯云的产品中，与列表ADT实例相关的产品是对象存储（COS）服务。对象存储是一种云存储服务，可以存储和检索任意类型的数据，包括文件、图片、视频等。在对象存储中，可以将多个对象（即文件）合并成一个存储桶（Bucket），类似于将多个列表合并成一个列表的操作。腾讯云的对象存储产品提供了丰富的API和SDK，方便开发者使用和管理存储桶和对象。
腾讯云对象存储产品介绍链接：https://cloud.tencent.com/product/cos
相关·内容
从问题中分离出来。从直觉上讲，我已经理解了sequenceA在这个用例中所做的事情，但不理解是如何/为什么那样工作的。
因此，这一切归结为这样一个问题:在下面的情况下，sequenceA是如何工作的？
> sequenceA [("a",1),("b",2),("c",3)]
("abc",[1,2,3])
我看到了
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
所以在上面的usecase中，Traversable是[]，而Ap
浏览 3提问于2020-10-02得票数 5
回答已采纳
1回答
为了熟悉无形体，我研究了的例子。我对案例类迁移特别感兴趣。因此，我深入研究了的案例类迁移部分。
不幸的是，案例类迁移案例研究的代码并没有编译，因为添加了字段的最后一次转换失败了，因为找不到任何关联。
我正在努力理解代码的问题。然而，理解这个问题是相当困难的，到目前为止，我失败了。因此，我想问一问，是否有人可以给我一个提示。
我还尝试了几个编译器，即Scala2.12、Scala2.13。
我确实使用-Xlog-implicits标志运行了编译器，它提供了几条错误消息：
[info] Icecream.scala:67:42: shapeless.this.Generic.materialize
浏览 8提问于2022-06-11得票数 1
我有两个特征及其实例对象定义如下：
package reflection
trait Monoid[T] {
def id: T
def op(lhs: T, rhs: T): T
}
trait ADTHelper[T]{
type V
def create(value: V): T
def get(adt: T): Any
}
case class Avg(avg: Double, n: Int)
object AvgMonoid extends Monoid[Avg] with ADTHelper[Avg]{
override def id: Avg =
浏览 2提问于2016-08-05得票数 2
回答已采纳
2回答
我正在将算法转换为Haskell。
我有两个函数，用于检查所有字符是否为ASCII，以及暴力破解是否可能：
filterAscii :: [String] -- ^terms to filter
-> [String] -- ^filtered terms
filterAscii = filter $ all (\ chr -> ord chr < 128)
和
filterShort :: [String] -- ^terms to filter
-> [String] -- ^filtered terms
filter
浏览 0提问于2013-01-01得票数 0
回答已采纳
我有一个类型的项目列表：[Right [(a, b)], Right [(a1, b1)], Right [(a2, b2)]]，我想获取Right [(a,b), (a1, b1), (a2, b2)]，可以吗？我使用sequence来做这件事，但是我得到了：Right [[(a,b)], [(a1, b1)], [(a2, b2)]]。我在想，有没有像concat这样的函数，可以去掉这些内括号，让它只是一个元组列表。
浏览 8提问于2021-03-26得票数 0
1回答
在"“的帮助下，我正在学习Haskell。我正在学习一个BST (二进制搜索树)的例子，它是Foldable的一个实例。
data Tree a = Nil | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)
instance F.Foldable Tree where
foldMap f Nil = mempty
foldMap f (Node x l r) = (F.foldMap f l) `mappend` (f x) `mappend` (F.foldMap f r)
当我运行F.foldMap (\x
浏览 1提问于2014-10-14得票数 1
回答已采纳
我有一个数据结构(它是玫瑰树的一个特定子类，它形成一个具有最大下界和最低上界函数的格)，它支持两个完全合理的函数作为Monoid类的mappend。
在haskell中有任何方法支持匿名Monoid实例吗？在这种情况下，我应该考虑使用诸如Template-Haskell之类的东西来为我生成类型类吗？
我想要的是一个让我动态创建实例的makeMonoid :: (RT a -> RT a -> RT a) -> Monoid a，但我理解这与我所理解的股票类型系统是不一致的。如果我只需要选择一个默认的合并函数并为其他合并编写newtype，我就没问题了，只是好奇
浏览 3提问于2015-02-21得票数 3
回答已采纳
假设我想让所有的数字都成为Monoid的实例。不必为每个Num创建一个实例，如下所示：
instance Monoid Int where
mappend = (+)
mempty = 0
instance Monoid Float where
mappend = (+)
mempty = 0.0
-- etc
有这样的东西吗？
instance Num t => Monoid t where
mappend = (+)
mempty = 0
编辑
一些人正在用GHC扩展和警告来回答潜在的问题；我发现这是信息丰富的，但我认为我会坚持使用Sum、Product和
浏览 0提问于2015-09-24得票数 8
回答已采纳
我有一张需要放在地图上的坐标清单。在julius中迭代列表是可能的吗？现在，我正在hamlet中创建一个隐藏表，并在julius中访问该表，这似乎不是一个理想的解决方案。有人能指出一个更好的解决方案吗？谢谢。
编辑:为列表传递一个JSON字符串(julius可以读取)似乎可以解决我的问题。
浏览 3提问于2012-05-21得票数 4
2回答
我正在尝试定义一个实例： newtype Join a = Join { getJoin :: a -> Bool }
deriving Generic
instance Monoid (Join a) where
f <> g = ???
mempty = ??? 目标是，如果列表中的所有函数都为真，则函数foldMap Join应该返回true，如果不是所有函数都为真，则返回false。 我了解foldMap，以及Monoid的Sum和Product实例，但除此之外，我对编写Monoid的新型实例非常陌生。任何正确方向的帮助都将不胜感激。谢谢。
浏览 22提问于2020-07-20得票数 7
我正在尝试使用折叠或更好的mkString来连接DList中的字符串。
val dlist = DList("a", "b", "c")
所以我得到一个字符串："abc"
显然，对于scala中的常规列表，list.mkString完成了这项工作。
在斯科比的分布式列表中有什么简单的方法可以做到吗？
浏览 3提问于2015-06-25得票数 1
回答已采纳
1回答
GHC前言中列表的默认monoid是连接。
[1,2,3] <> [4,5,6]变成了[1,2,3] ++ [4,5,6]，因此变成了[1,2,3,4,5,6]
我想写一个ZipList Monoid实例，它的行为如下：
[
1 <> 4
, 2 <> 5
, 3 <> 6
]
假设我使用的是和么半群，结果是[5,7,9]。请注意，它的行为类似于zipWith (+)
它的行为可能是这样的：
[
Sum 1 <> Sum 4
, Sum 2 <> Sum 5
, Sum 3 <> Sum 6
]
我需要
浏览 5提问于2018-05-02得票数 3
1回答
我试图从Haskell的输入中读取行，直到找到一个非空行为止。实际上，我知道如何简单地使用以下代码进行操作：
notEmpty [] = return ""
notEmpty (l:xs) = do
s <- l
if s /= "" then return s
else notEmpty xs
getLine' = notEmpty $ repeat getLine
Test (我输入了两个空行，然后是'foo')：
*> getLine'
foo
"foo"
浏览 3提问于2015-01-13得票数 1
回答已采纳
因为我在谷歌搜索这个问题有困难，所以我想我应该把它发到这里。
我只是对其背后的逻辑感兴趣，或者说，这仅仅是创建者选择使用++的首选。我的意思是，对于将两个字符串(或者更确切地说是列表)与+连接在一起的字符串，使用类型类型似乎不难想象。
编辑：我应该补充说，在Haskell中，人们不得不怀疑背后的原因，因为+和++是在类型类中定义的函数，而在java中，使用+进行字符串连接只是语言语法的一部分，因此只受创建者的偏好/意见的制约。(到目前为止的答案表明，我的怀疑是正确的。)
此外，haskell来自数学背景，深受数学语法的影响，因此可能有更深层次的原因，而不仅仅是偏好/意见。
浏览 1提问于2018-04-14得票数 4
回答已采纳
假设我们有一个元组列表，我们需要在某个准则上找到最大值。标准如下-最重要的是元组的第一个元素(越多越好)次要的是第二个元素(越少越好)。
我知道用Haskell表达这一点的两种方法。
第一种方法是创建一个函数，用于进行所有比较并返回(EQ, LT, GT)
compareSol (s1, w1) (s2, w2) = if weightComp == EQ then sizeComp else weightComp where
weightComp = compare w1 w2
sizeComp = compare (Map.foldl' (+) 0 s2) (M
浏览 4提问于2017-04-01得票数 2
回答已采纳
我怀疑所有可应用的、可折叠的单子叶都是以同样的方式通过的。换句话说，对于满足Applicative和Foldable且所有实例化t a满足Monoid的任何类型的Traversable，都有一个Traversable的免费实例。
下面是我如何实现sequenceA
sequenceA :: (Applicative t, Foldable t, Monoid (t a), Applicative f) =>
t (f a) -> f (t a)
sequenceA = foldl (liftA2 $ \b a -> mappend b (pure a)) (pure me
浏览 0提问于2018-05-01得票数 1
回答已采纳
我正在处理一些缺少值的数据，这些值被简单地表示为可能值的列表。我想要执行各种聚合/统计操作，这些操作忽略了丢失的值。
这与以下问题有关：
但是，如果缺少任何值，则返回Nothing满足于前一个问题，在我的情况下，这不是一个选项。我有一个解决方案，它涉及为Num创建一个Maybe实例。然而，这意味着它是特殊的加法和乘法，它也有一些其他的问题。
instance Num a => Num (Maybe a) where
negate = fmap negate
(+) = liftA2 (+)
(*) = liftA2 (*)
f
浏览 3提问于2016-10-06得票数 4
回答已采纳
我正在学习无形状的知识，目前我正在尝试创建一个函数来执行以下操作:给定一个HList类型，它返回HList of Nones，而Option类型对应于给定的HList类型。
例如：
create[String :: Int :: HNil] // returns None[String] :: None[Int] :: HNil
因此，逻辑如下：
def create[A <: HList] {
type HT = ??? //somehow getting Head type
type TT = ??? //somehow getting Tail type
// if HT i
浏览 3提问于2016-05-21得票数 3
回答已采纳
2回答
在 nicely 中如何使用。我希望具有类似的效果，但将函数列表作为参数：
tryFuncs :: [a -> Maybe b] -> a -> Maybe b
...
所以像这样的电话
tryFuncs [f, g, h] x
将成为可能，并做同样的事情
(f x) `mplus` (g x) `mplus` (h x)
如何才能做到这一点？
浏览 1提问于2014-05-20得票数 2
回答已采纳
1回答
我试图实现一个排序的多属性排序，它适用于任何东西的列表。
import Data.Ord (Ordering, Down (..), comparing)
import Data.List (sortBy)
import Data.Monoid (mconcat)
data Order a = ASC a | DESC a
orderBy :: Ord b => [Order (a -> b)] -> [a] -> [a]
orderBy rankedProperties unsorted =
sortBy rankedCompare unsorted
浏览 3提问于2016-05-21得票数 1
回答已采纳
3回答
避免不完全模式匹配
、、、
考虑以下代码：
data A
data B
f :: A -> B
f = undefined
data T = TA A | TB B
data ListT = ListTA [A] | ListTB [B]
g :: [T] -> ListT
g l =
let
f' :: T -> B
f' (TA x) = f x
f' (TB x) = x
isA :: T -> Bool
isA TA{} = True
isA TB{} = False
in
case (all
浏览 4提问于2017-07-06得票数 8
回答已采纳
假设我有一个字符串列表，我想先按字符串长度排序，然后按字母顺序排序(因此列表中具有相同长度的字符串按字母顺序排序)。 我已经有了ordString，它可以用来按字母顺序排序。我可以为字符串长度创建自己的Ord实例： import * as S from 'fp-ts/string'
import * as N from 'fp-ts/number'
import * as Ord from 'fp-ts/Ord'
const ordString = S.Ord
const ordStringLength = pipe(N.Ord, Ord.
浏览 21提问于2021-10-25得票数 3
回答已采纳
1回答
我正在努力学习haskell和阅读这本书。
在这本书中，作者提到了更大的类型如下：
instance Monoid b => Monoid (a -> b)
instance (Monoid a, Monoid b) => Monoid (a, b)
instance (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)
这些Monoid的共同之处在于，它们通过重用表示较大类型组件的Monoid实例，为更大的类型提供了一个新的Monoid。
他用更大的数据类型是什么意思？
浏览 2提问于2017-06-26得票数 1
回答已采纳
1回答
我正在努力理解类型化，到目前为止，我已经了解了Monoids，这是非常简单的：
object AbstractAlgebra {
case class Pair[A,B](a: A, b: B)
trait Monoid[T] {
def times(t1: T, t2: T): T
def unit: T
}
object Monoid {
implicit object MonoidIntPlus extends Monoid[Int] {
def times(i1: Int, i2: Int) = i1 + i2
def
浏览 1提问于2017-05-16得票数 1
回答已采纳
我使用以下函数处理Haskell返回类型多态性：
f :: [a] -> [a]
f [] = mempty
f (x:xs) = [x] <> f xs
很明显它什么都没做。我想要做的是修改类型，以便它接受一个列表并返回一个Monoid容器，其中一个可以是list。我被困在这里是因为Monoid采用一种类型的参数。我不知道这种类型是什么：f :: Monoid m => [a] -> ?
这个是可能的吗？
浏览 0提问于2019-06-06得票数 1
回答已采纳
2回答
我正在尝试做一个函数，把一个索引放到一个森林中，一个整数列表来选择一种在树下的方式，然后把它变成一个透镜，聚焦同样的元素。
实际上，这与(t :: Data.Tree.Forest) ^@.. itraversed <.> itraversed所做的正好相反。
以下是我的尝试：
pathToLens :: (Applicative f) => (Int, [Int]) -> LensLike' f (Data.Tree.Forest a) (Data.Tree.Tree a)
pathToLens (rootIdx, branchIndices) =
i
浏览 3提问于2020-11-20得票数 0
回答已采纳
我只是不知道如何在haskell中为我的数据类型实现一个特殊的ord。我在论坛上看到，它应该看起来有点像这样：
import Data.Set
data Cord = Cord { x :: Int
, y :: Int} deriving (Eq,Ord)
instance Eq Cord where
(Cord a b) == (Cord a b) = (a==c and b==d)
instance Ord Cord where
compare (Cord a b) (Cord c d) = if a==c then compar
浏览 3提问于2015-10-02得票数 3
1回答
我经常开始考虑要定义的类型类的问题，并意识到当我开始编写代码时，我不需要类型类，可以用代数数据类型来解决我的问题，这似乎更简单。因此，我想知道什么时候需要类型类。
据我所理解，类型类是一种表示某些函数存在于某些类型的方法。例如，当类型MyType是Monoid的一个实例时，我就可以使用函数mempty :: MyType和mappend :: MyType -> MyType -> MyType，从而使单面律成立。
对于代数数据类型，我们也可以这样做，方法是将Monoid定义为类型而不是类型：
data Monoid a = Monoid { mempty :: a
浏览 0提问于2017-11-28得票数 3
回答已采纳
我正在试图了解scalaz是如何组织的，我想知道常见的monad (或其他类型)实例(如MonadInt、MonadList )在哪里.被定义为。
以MonadList为例。我看到scalaz.std模块包含ListInstances特征，它包含列表的某些类型实例(如MonoidList )的隐式值。这个隐式值定义了单类列表实例的附加函数。
是否有地方可以为MonadList找到一个隐式值，该值定义了列表的点和绑定？
浏览 3提问于2015-09-30得票数 0
回答已采纳
学习Haskell函子、应用函子和一元论章节，面对一个新的问题，我的代码在这里，尽管我试图解决我做不到的问题，我的代码在这里：
class Monoid m where
mempty :: m
mappend :: m -> m -> m
instance Monoid a => Monoid (Maybe a) where
mempty = Nothing
Nothing `mappend` m = m
m `mappend` Nothing = m
Just m1 `mappend` Just
浏览 6提问于2017-03-18得票数 0
回答已采纳
1回答
根据Harper ()，看起来Type类提供的抽象级别与Modules提供的抽象级别不同，而且我很难准确地找出原因。在这个链接中没有例子，所以我很难看到关键的区别。还有关于如何在模块和类型类()之间进行转换的其他文章，但这与程序员的实现并没有任何关系(它只是说，没有一个可以做到的事情是另一个不能模仿的)。
具体来说，在中
首先，他们坚持认为类型可以完全以一种方式实现类型类。例如，根据类型类的哲学，整数可以精确地以一种方式(通常的排序)排序，但显然有许多顺序(例如，按可分性)。第二个问题是，它们混淆了两个不同的问题:指定类型是如何实现类型类的，以及在类型推断期间应该何时使用这样的规范。
浏览 2提问于2016-04-28得票数 27
回答已采纳
1回答
我最近在标准ML中玩单曲。签名很容易写成：
signature MONOID =
sig
type monoid
val neutral : monoid
val combine : monoid -> monoid -> monoid
end
简单的幺半群也是如此，例如整数加法幺半群：
structure IntSumMonoid : MONOID =
struct
type monoid = int
val neutral = 0
fun combine a b = a + b
end
但是，我被困在为更高类型的类(如list )定义一个幺半群时。当然，
浏览 3提问于2015-01-14得票数 1
回答已采纳
1回答
应该有两个操作: mempty是一个中性元素，mappend是一个关联的二元操作。我不能决定什么是设计monoid的合适方式。我可以使用模板专门化
template<typename T>
T mappend(const T &left_operand, const T &right_operand);
template<typename T>
T mempty();
struct Min {
int value;
};
template<>
Min mappend<Min>(const Min &left_
浏览 14提问于2018-02-15得票数 0
回答已采纳
我创建了一个数据类型，它是其他元素的列表，比如
data Tarr = Tarr [Int] deriving (Show)
我想把这些名单中的两个连在一起
Tarr [0,2,4,2] ++ Tarr [1]
但我犯了个错误
<interactive>:43:1:
Couldn't match expected type `[a0]' with actual type `Tarr'
如果存在类型类型(++) (Concat )，就像for (==) (Eq)一样，我可以将其实现为类似于
class Concat a where
(+++)
浏览 11提问于2013-12-28得票数 0
回答已采纳
让我们看看在Haskell中用于处理反向列表的新数据类型的声明：
import Data.Monoid
data RevList a = Nil | RCons (RevList a) a deriving (Eq, Show)
instance Monoid a => Monoid (RevList a) where
mempty = Nil
instance Semigroup a => Monoid (RevList a) where
Nil <> RCons (RevList a) a = RCons (RevList a) a
R
浏览 8提问于2020-01-01得票数 3
1回答
我正在继续做文本的练习。
下面的函数productMonoid由两个么半群组成。
//@author - pchiusano
def productMonoid[A, B](A: Monoid[A], B: Monoid[B]): Monoid[(A, B)] = {
new Monoid[(A, B)] {
def op(x: (A,B), y: (A,B) ) = (A.op(x._1, y._1) , B.op(x._2, y._2))
val zero = (A.zero, B.zero)
}
}
接下来是整数乘法么半群。
val int
浏览 1提问于2013-11-14得票数 2
给出一个Maybe Int，我试着将它mappend到自己。
$let x = Just 55 :: Maybe Int
$mappend x x
<interactive>:126:1:
No instance for (Monoid Int) arising from a use of `mappend'
In the expression: mappend x x
In an equation for `it': it = mappend x x
看着，我看到：
么半群a =>么半群(可能是a)
由于不实现Monoid类型类
浏览 16提问于2015-04-08得票数 24
回答已采纳
有没有一种标准的方法来将左侧展平成一个单独的列表？
谢谢!
浏览 5提问于2012-10-03得票数 3
回答已采纳
3回答
在Haskell中，我们可以使用类似于超类约束的实例声明。我将给出一个使用Semigroup和Monoid的例子。以下是Semigroup的简化定义
class Semigroup a where
(<>) :: a -> a -> a
下面是Monoid定义的简化版本，它使用了超类约束：
class Semigroup a => Monoid a where
mempty :: a
mappend :: a -> a -> a
mappend = (<>)
如果我没有弄错，
浏览 2提问于2022-06-08得票数 6
回答已采纳
2回答
我正在尝试这个(为了学习目的)：
{-# LANGUAGE FlexibleInstances #-}
instance Monoid (a -> a) where
mempty = id
mappend f g = f . g
期望id <> id等于id . id
但是，对于(id <> id) 1，我会收到以下错误：
Non type-variable argument in the constraint: Monoid (a -> a)
我该换什么来运行它呢？
这只是为了更好地理解单字和Haskell打字机，而不是为了任何实际的用途。
浏览 1提问于2016-06-18得票数 3
回答已采纳
在刚刚学习函数式编程并完成Cats 在线Scala练习的程序员的背景下，以下结果似乎令人费解：
import cats._
import cats.implicits._
object Foo {
def main(args: Array[String]): Unit =
println(Foldable[List].fold(List(None, Option("two"), Option("three"))))
//Some("twothree")
println(Foldable[List].foldK(Li
浏览 0提问于2018-09-07得票数 4
回答已采纳
1回答
拥有这些进口品：
> import Control.Lens
Control.Lens> import qualified Data.Map as Map
以及定义如下的映射值：
Control.Lens Map> let m = Map.fromList [('a', 1), ('c', 3), ('b', 2)]
我可以一个接一个地得到这样的元素：
Control.Lens Map> view (at 'b') m
Just 2
我想知道的是，有一套这样的钥匙：
Control.Lens Map>
浏览 5提问于2013-06-17得票数 20
回答已采纳
为什么
(mempty :: String)
工作，但是
(mempty :: Maybe Bool)
给了我一个关于Bool没有Monoid类型类的错误，但这有什么关系呢，它可能已经被包装起来了？
浏览 0提问于2017-03-14得票数 0
2回答
问题
假设您在一个公共API中有一个函数，它需要返回某种集合。它的类型类似于
foo :: a -> b
其中b是某种集合。
据我所见，有三种主要的收藏品--至少它们是最常用的：
顺序(顺序重要，可能有重复)
集合(订单不重要，没有副本)
映射(元素是键值对，顺序不重要，没有重复的键)
在这三种情况下，您应该为b使用什么？我曾考虑过三种选择，但可能还有更多。
A.只需返回一个列表
在这个替代方案中，您只需返回所有内容的列表：
foo :: a -> [c]
foo :: a -> [c] (并且文档中没有副本)
foo :: a -> [(k, c)] (并且文档中没有
浏览 0提问于2014-05-03得票数 7
回答已采纳
根据类的名称和在解析器中的用法以及在Maybe中的用法，我认为它的行为应该是从a <|> b <|> c中选择第一个非空输入。所以我希望输入是这样的
[] <|> [1] <|> [2, 3]
它将返回第一个非空列表，即：
[1]
但它实际上只是将整个过程连接在一起，产生：
[1,2,3]
所以我想知道这样一个实现背后的原因是什么？它实际上是正确的吗？
附言:有没有什么标准函数可以完成我对Alternative的期望
浏览 2提问于2013-01-07得票数 4
回答已采纳
这个问题最初是在我开发动态JS类型验证器时出现的，该验证器依赖于字典传递样式作为相当简单的类型类机制，但我认为它也适用于Haskell或其他具有类型类机制的语言。
一开始，我认为在使用字典传递样式的设置中允许每个类型有几个类型类实例不是太大的问题，因为我可以完全控制类型类的解析。但实际的问题似乎是维护类型安全，而不是类型类解析，正如我将使用类型验证器演示的那样。因为代码是带类型注释的，所以它在某种程度上是语言不可知的。
// please assume `Number` to be a non-polymorphic `Int` type
Sum.Monoid
浏览 15提问于2021-07-08得票数 5
2回答
我想先按一个属性排序，然后再按另一个属性排序(如果第一个属性是相同的)。
在Haskell中，合成两个比较函数的惯用方法是什么，即与sortBy一起使用的函数
给定的
f :: Ord a => a -> a -> Ordering
g :: Ord a => a -> a -> Ordering
合成f和g将会产生如下结果：
h x y = case v of
EQ -> g x y
otherwise -> v
where v = f x y
浏览 0提问于2012-07-15得票数 36
回答已采纳
2回答
当然，数据类型并不精确，但这是如何(或多或少)实现Monoid Bool的吗？
import Data.Monoid
data Bool' = T | F deriving (Show)
instance Monoid (Bool') where
mempty = T
mappend T _ = T
mappend _ T = T
mappend _ _ = F
如果是这样/不是，那么让Bool's mappend成为OR和AND的理由是什么？
浏览 3提问于2014-10-27得票数 6
回答已采纳
从这种Getter类型开始
type Getter s a = forall r. (a -> Const r a) -> s -> Const r s
我们需要一个额外的Monoid约束来获得一个Fold
type Fold s a = forall r. Monoid r => (a -> Const r a) -> s -> Const r s
但是Fold的实际和更一般的类型是
type Fold s a = forall f. (Contravariant f, Applicative f) => (a -> f a) ->
浏览 1提问于2019-08-10得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
