小编And*_*kin的帖子

我知道这方面有很多问题,但我创造了一个我认为应该有用的简单例子,但仍然没有,我不确定我理解为什么

val myStrings = new Array[String](3)
// do some string initialization

// this works
myStrings.foreach(println(_))


// ERROR: missing parameter type for expanded function
myStrings.foreach(println(_.toString))

有人可以解释为什么第二个语句不编译？

Scala中以下泛型定义之间有何不同:

class Foo[T <: List[_]]

和

class Bar[T <: List[Any]]

我的直觉告诉我他们差不多,但后者更明确.我发现前者编译的情况,但后者不编,但不能指出确切的区别.

谢谢!

编辑:

我可以把另一个扔进去吗？

class Baz[T <: List[_ <: Any]]

问这个问题是为了澄清我对类型类和更高级别类型的理解,我不是在寻找Java中的变通方法.

在Haskell中,我可以写出像

class Negatable t where
    negate :: t -> t

normalize :: (Negatable t) => t -> t
normalize x = negate (negate x)

假设Bool有一个实例Negatable,

v :: Bool
v = normalize True

一切正常.

在Java中,似乎不可能声明适当的Negatable接口.我们可以写:

interface Negatable {
    Negatable negate();
}

Negatable normalize(Negatable a) {
    a.negate().negate();
}

但是,与Haskell不同,以下不会在没有强制转换的情况下编译(假设MyBoolean工具Negatable):

MyBoolean val = normalize(new MyBoolean()); // does not compile; val is a Negatable, not a MyBoolean

有没有办法在Java接口中引用实现类型,或者这是Java类型系统的基本限制？如果是限制,是否与更高级别的支持相关？我认为不是:看起来这是另一种限制.如果是这样,它有名字吗？

谢谢,如果问题不清楚,请告诉我!

我有点困惑,需要有人帮我.让我们概述一下我目前的理解:

Eendofunctor 在哪里,是一个A类别:

E : A -> A.

由于Haskell中的所有类型和态射都属于该Hask类别,Haskell中的任何函子都不是一个endofunctor？F : Hask -> Hask.

我有一种很好的感觉,我错了,并以某种方式过度简化了这一点,我希望有人告诉我,我是一个多么的白痴.谢谢.

我想有一个函数,用于将纯函数映射到容器或通过它对应用/ monadic动作进行排序.对于纯映射,我们有

fmap :: Functor f => (a -> b) -> (f a -> f b)

对于monadic测序,我们有(来自Data.Taversable)

mapM :: (Traversable f, Monad m) => (a -> m b) -> (f a -> m (f b))

这是类似的

mapKleisli :: (Traversable f, Monad m) => Kleisli m a b -> Kleisli m (f a) (f b)
mapKleisli = Kleisli . mapM . runKleisli

我们知道( - >)和(Kleisli m)都是类别(和箭头).所以自然要做出概括:

mapCategory :: (X f, Category c) => c a b -> c (f a) (f …

在我的SBT项目中,我有一个输入文件,src/main/greeting/Greeting.txt其中包含以下内容:

Hello, world!

这是我build.sbt从Greeting.txt文件中生成Scala源:

sourceGenerators in Compile += Def.task{
  println("GENERATING FILES")
  val inputFile = file("src/main/greeting/Greeting.txt")
  val generatedFile =
    (sourceManaged in Compile).value / "scala" / "Main.scala"
  val greeting = IO.read(inputFile).trim
  IO.write(
    generatedFile,
    s"""object Main extends App { println("${greeting}") }"""
  )
  Seq(generatedFile)
}.taskValue

这build.sbt很好,除了它每次编译/运行我的项目时都运行我的任务来生成Scala源.我希望它只在Greeting.txt-file已更改时运行这些任务.我怎样才能做到这一点？

MCVE

生成项目的Bash脚本:

#!/bin/bash
mkdir sourceGeneratorsExample
cd sourceGeneratorsExample
mkdir -p src/main/scala
mkdir -p src/main/greeting
echo "Hello, world!" >> src/main/greeting/Greeting.txt
cat <<HEREDOC > build.sbt
sourceGenerators in …

我有一个MyStruct采用泛型参数的结构，T: SomeTrait我想new为MyStruct. 这有效：

/// Constraint for the type parameter `T` in MyStruct
pub trait SomeTrait: Clone {}

/// The struct that I want to construct with `new`
pub struct MyStruct<T: SomeTrait> {
    value: T,
}

fn new<T: SomeTrait>(t: T) -> MyStruct<T> {
    MyStruct { value: t }
}

fn main() {}

我想把这个new函数放在一个impl像这样的块中：

impl MyStruct {
    fn new<T: SomeTrait>(t: T) -> MyStruct<T> {
        MyStruct { value: t }
    } …

我正在阅读"Scala for the Impatient",他们在8.8中说:

[..]你可以使用abstract关键字来表示一个无法实例化的类[..]

abstract class Person { val id: Int ; var name: String }

几行之后:

您始终可以使用匿名类型自定义抽象字段:

val fred = new Person {

  val id = 1729

  var name = "Fred"

}

因此,他们用匿名类型人工实例化Person类.在现实世界的哪种情况下,人们会想要这样做？

Scala社区.

目前我正在尝试使用猫ValidatedMonad 实现自定义模型/单参数验证.但是,从1.0开始删除笛卡尔积之后,我无法使用(v1 | @ | v2)map(f)并且无法编译我的代码:

import cats.Semigroupal
import cats.data.Validated.{Invalid, Valid}
import cats.data.{ValidatedNel, _}
import cats.implicits._
import cats.instances.all._

case class FieldErrorInfo(name: String, error: String)

type FieldName = String

type ValidationResult[A] = ValidatedNel[FieldErrorInfo, A]

trait SingleFieldValidationRule[U] extends ((U, FieldName) => ValidationResult[U])

trait ModelValidationRule[M] extends (M => ValidationResult[M])

object ValidateNameRule extends SingleFieldValidationRule[String] {
  override def apply(v1: String, name: String): ValidationResult[String]  = {
    if (v1.contains("cats"))
      v1.validNel
    else
      FieldErrorInfo(name, "Some Error").invalidNel
  }
}

object ValidateQuantityRule extends SingleFieldValidationRule[Int] {
  override def apply(v1: …

什么构成纯函数式编程的价值？

看到一句话后我问自己这些问题:

Task(或IO)有一个构造函数,可以将副作用捕获为值.

• 功能是一个值吗？
  • 如果是这样,在将两个函数等同时它意味着什么:assert(f == g).对于两个相同但单独定义的函数=> f != g,为什么它们不起作用1 == 1？
• 方法的对象是值吗？(例如IO { println("") })
• 具有setter方法和可变状态的对象是一个值吗？
• 具有可变状态的对象是否作为状态机的值？

我们如何测试某些东西是否有价值？不变性是一个充分条件吗？

更新:我正在使用Scala.