小编Wei*_*Lin的帖子

我想实现一个无限的列表:

abstract class MyList[+T]
case object MyNil extends MyList[Nothing]
case class MyNode[T](h:T,t: => MyList[T]) extends MyList[T]

//error: `val' parameters may not be call-by-name

问题是call-by-name不允许的.

我听说这是因为val或者var不允许使用构造函数参数call-by-name.例如:

class A(val x: =>Int) 
//error: `val' parameters may not be call-by-name

但矛盾的是,正常的构造函数的参数仍然是val,尽管private.例如:

class A(x: =>Int) 
// pass

所以问题是:

• 问题真的是关于val还是var？
  • 如果说.由于按名称调用的要点是推迟计算,为什么不能call-by-name或val计算(或初始化)被推迟？
• 如何绕过cass类来实现无限列表？

根据Erik Osheim的幻灯片,他说继承可以解决与类型类相同的问题,但提到继承有一个问题叫做:

脆弱的遗产噩梦

并说继承是

将多态性与成员类型紧密耦合

他的意思是什么？

在我看来,继承很擅长扩展,要么改变现有类型的实现,要么添加新的成员类型(子类型)到接口.

trait Foo { def foo }

class A1 extends Foo{
  override def foo: Unit = ???
}

//change the foo implementation of the existing A1
class A2 extends A1 with Foo{  
  override def foo = ???
}

// add new type B1 to Fooable family
class Bb extends Foo{        
  override def foo = ???
}

现在就类型类而言:

trait Fooable[T] { … }
def foo[T:Fooable](t:T) = …

class Aa {…}
class Bb {…} …

我所知道
的 Python 数据类允许使用数据类或类进行继承。在最佳实践中（以及在其他语言中），当我们进行继承时，应该首先调用初始化。在 Python 中它是：

def __init__(self):
    super().__init__()
    ...

我在做什么
因为数据类是在 Python 3.7 中引入的，所以我正在考虑用数据类替换我的所有类。使用 dataclass，它的好处之一是__init__为您生成。当数据类需要继承基类时，这并不好——例如：

class Base:
    def __init__(self):
        self.a = 1

@dataclass
class Child(Base):
    a:int
    def __post_init__(self):
        super().__init__() 

我的问题
问题是我们必须将超级初始化调用放入__post_init__其中，实际上是在dataclass 的init之后调用的。
缺点是我们失去了约定契约，初始化混乱导致我们无法覆盖超类的属性。

可以通过 的概念解决__pre_init__。我已经阅读了该文档，但没有看到与该概念有任何关系。我错过了什么吗？

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

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

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

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

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

更新:我正在使用Scala.

这只是scikit-learn管道的一个小问题.

在课堂上sklearn.pipeline.FeatureUnion,有一个transformer_weights选项.

transformer_weights:dict,optional
:每个变压器的特征的乘法权重.键是变换器名称,值是权重.

我在一个例子中看到了对不同特征赋予不同权重的用法.

    transformer_weights={
        'subject': 0.8,
        'body_bow': 0.5,
        'body_stats': 1.0,
    },

这对我来说是无稽之谈,因为分类器将在以后为你学习加权.为什么还要费心呢？

我已经使用多个线程很长时间了，但无法解释这种简单的情况。

import java.util.concurrent.Executors
import scala.concurrent._
implicit val ec = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(1))

def addOne(x: Int) = Future(x + 1)
def addTwo(x: Int) = Future {addOne(x + 1)}

addTwo(1)
// res5: Future[Future[Int]] = Future(Success(Future(Success(3))))

令我惊讶的是，它有效。而且我不知道为什么。

问题：
为什么给定一个线程可以同时执行两个Future？

我的期望：
第一个Future（addTwo）占用一个唯一的线程（newFixedThreadPool(1)），然后调用另一个Future（addOne），这又需要另一个线程。
因此，程序最终将因线程不足而陷入困境。

我_用作占位符来创建匿名函数,问题是我无法预测Scala将如何转换我的代码.更确切地说,它错误地确定了我想要的"大"匿名函数的大小.

 List(1,2,3) foreach println(_:Int)   //error !
 List(1,2,3) foreach (println(_:Int)) //work
 List(1,2,3) foreach(println(_:Int))  //work

使用-Xprint:typer我可以看到Scala将第一个转换为"一个大的匿名函数":

x$1 => List(1,2,3) foreach(println(x$1:Int))

工作的第2个3号是正确的转变成我想要的.

... foreach (x$1 => println(x$1:Int)) 

为什么这个？规则是什么？

这个简化的案例是我的问题发生在...

object Main extends IOApp{
 def run(args:Seq[String]): IO[ExitCode]={
    Task{...}
     .to[IO]
     .as(ExitCode.Success)
 }
}

另一种选择是Await.result(task)，但是这听起来不太符合IOApp的做法。

我知道的

根据这个伟大的帖子Monix vs Cats Effect
我看到之间Task IO的差异是：

• Task API比 IO
• Task在线程调度公平性方面更加智能和自动化
• Task 获得更多可取消选项
• 和更多 ...