我有以下代码:
foldr const 0 ([1] ++ undefined)
我得到了结果1.
我知道,这foldr是正确的关联.写出上面的例子:
const 1 (const undefined 0)
为什么括号中的表达式不会被评估为第一个？
因为函数应用程序的优先级高于括号？
我有以下类型声明:
data MyType = MyVal Int deriving (Eq, Show)
如您所见,它只有一个带参数的数据类型构造函数.
在书中,它说:
因为MyVal有一个Int参数,所以MyType类型的值必须包含一个 - 只有一个 - Int值
为什么IntMyType类型的值或它是什么意思？
我有以下声明:
data Two a b = Two a b deriving (Eq, Show)
instance (Semigroup a, Semigroup b) => Semigroup (Two a b) where
(Two a b) <> (Two c d) = Two (a <> c) (b <> d)
并在前奏中尝试过:
*Main First Lib MonoidLaws Semi> (Two a b) <> (Two c d) = Two (a <> c) (b <> d)
<interactive>:10:3: error:
* Occurs check: cannot construct the infinite type: t1 ~ Two t1 t1
Expected type: t1 -> t -> …我有以下代码片段:
Prelude Data.Monoid> :t 1 <> (2 :: Sum Integer)
1 <> (2 :: Sum Integer) :: Sum Integer
怎么1变成Sum Integer打字？
更新
我玩了一下mappend功能并发现:
Prelude Data.Monoid> x = mappend 43
为什么mappend会接受这个号码43？43是一个Num类型,它没有monoid实例.
我有以下Traversable实例:
instance Traversable (Three' a) where
traverse f (Three' x y z) = Three' x <$> f y <*> f z
中缀运算符<$>并<*>具有相同的优先级,即4.
*ExercisesTraversable> :i <$>
(<$>) :: Functor f => (a -> b) -> f a -> f b
-- Defined in ‘Data.Functor’
infixl 4 <$>
*ExercisesTraversable> :i <*>
class Functor f => Applicative (f :: * -> *) where
...
(<*>) :: f (a -> b) -> f a -> f b
...
-- Defined …我有两个功能,我正在努力compose:
private def convert(value: String)
: Path = decode[Path](value) match {
private def verify(parsed: Path)
: Path = parsed.os match {
我尝试过如下:
verify compose convert _
编译器抱怨:
[error] Unapplied methods are only converted to functions when a function type is expected.
[error] You can make this conversion explicit by writing `verify _` or `verify(_)` instead of `verify`.
[error] verify compose convert _
[error] ^
[error] one error found
我想完成以下事项:
def process(value: String)
: Path =
verify(convert(value))
我究竟做错了什么？
我有以下代码:
import cats._
import cats.Functor
object StudyIt {
def main(args: Array[String]): Unit = {
val one: Int = 1
val a = Functor[Id].map(one)(_ + 1)
println(a)
}
}
正如你所看到的,map期望的类型Id[Int],但我只是过去Int到map,为什么它是可能的吗？
我想弄明白,如果Bool -> Maybe ()是同构的话.
可能的组合是:
True -> Just ()
True -> Nothing
False -> Just ()
False -> Nothing
我会说,它是同构的,并且对于每种组合,它都存在单独的函数来反转它.
如何证明上述态射是同构的？
我正在尝试从页面https://ocharles.org.uk/posts/2014-12-17-overloaded-strings.html了解语言扩展名OverloadedStrings .
启用OverloadedStrings后,将String成为一个类型Data.String.IsString a => a:
Prelude Data.String> :t fromString "Foo"
fromString "Foo" :: IsString a => a
在描述中,作者提到了以下内容:
通过启用此扩展,字符串文字现在是对fromString函数的调用,该函数属于IsString类型类.
这是什么string literals are now a call to the fromString function？
并且作者还提到:
这种多态性非常强大,它允许我们在Haskell源代码中编写嵌入式域特定语言,而不必为其他正常值引入新的构造.
什么without having to introduce new constructs for otherwise normal values意思？
我正在尝试使用flatMapConcat如下：
Source.empty
.flatMapConcat {
Source.fromFuture(Future("hello"))
}
.runWith(Sink.foreach(println))
.onComplete {
case Success(_) =>
println()
case Failure(e) =>
println(s"Thrown ${e.getMessage}")
}
编译器抱怨：
Error:(31, 26) type mismatch;
found : akka.stream.scaladsl.Source[String,akka.NotUsed]
required: ? => akka.stream.Graph[akka.stream.SourceShape[?],?]
Source.fromFuture(Future("hello"))
我究竟做错了什么？