小编Fre*_*ind的帖子

Java代码:

class Animal {}
class Cat extends Animal {}
class Box<T> {}

public class Test {
    public void hello(Box<? extends Animal> box) {}
}


Box<Animal> box1 = new Box<Animal>();
Box<Cat> box2 = new Box<Cat>();
new Test().hello(box1);
new Test().hello(box2);

从Liskov替换原则,因为box2类型Box<Cat>可以在需要类型的地方使用Box<? extends Animal>,我可以说:

Box<Cat> is subtype of Box<? extends Animal>

其实:我不是,如果甚至不确定Box<? extends Animal>和? extends Animal有型

首先定义一个列表:

val list = List(1,2,3)

Scala编译器发出警告(即使它可以匹配):

list match {
  case head :: tail => println(s"h:${head} ~ t: ${tail}")
}

Scala编译器不会发出警告(即使它不匹配):

list match {
  case List(a,b) => println("!!!")
}

我无法理解第二个

从文件:http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/,它说:

Bool和Add()()是等价的,因为我们可以定义一个"from"和"to"函数:

to :: Bool -> Add () ()
to False = AddL ()
to True  = AddR ()

from :: Add () () -> Bool
from (AddL _) = False
from (AddR _) = True

Run Code Online (Sandbox Code Playgroud)

那:

from (to a) == a
to (from a) == a

Run Code Online (Sandbox Code Playgroud)

然后又给了另外两个:

 Add Void a === a
 Add a b === Add b a

如何为这两个写"from"和"to"函数？

我正在阅读这篇博客:http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/

它说:

但是,当我谈到相等时,我并不是指(==)函数意义上的Haskell相等.相反,我的意思是这两种类型是一对一的对应 - 也就是说,当我说两种类型a和b相等时,我的意思是你可以编写两个函数

    from :: a -> b
    to   :: b -> a

Run Code Online (Sandbox Code Playgroud)

将a的值与b的值配对,以便以下等式始终保持(这里==是真的,Haskell风格的等式):

    to (from a) == a
    from (to b) == b

Run Code Online (Sandbox Code Playgroud)

后来,基于这个定义的法律很多:

Add Void a === a
Add a b === Add b a
Mul Void a === Void
Mul () a === a
Mul a b === Mul b a

我不明白为什么我们可以根据"平等"的定义安全地获得这些法律？可以使用其他定义吗？我们可以用这个定义做什么？对Haskell类型系统有意义吗？

假设我有一个全局对象：

class Global {
   public static int remoteNumber = 0;
}

有一个线程定期运行以从远程获取新号码，并更新它（仅写入）：

new Thread {
   @override
   public void run() {
       while(true) {
           int newNumber = getFromRemote();
           Global.remoteNumber = newNumber;
           Thread.sleep(1000);
       }
   }
}

并且有一个或多个线程remoteNumber随机使用这个全局（只读）：

int n = Global.remoteNumber;
doSomethingWith(n);

你可以看到我没有使用任何锁或synchronize保护它，对吗？是否有任何可能导致问题的潜在问题？

更新：

就我而言，读取线程必须实时获取最新的新值并不重要。我的意思是，如果有任何问题（由于缺少锁/同步导致）使一个读取线程错过了该值，这并不重要，因为它很快就会有机会运行相同的代码（可能在循环中）

但是不允许读取未确定的值（我的意思是，如果旧值为 20，则新的更新值为 30，但读取线程读取的值不存在，例如 33，我不确定是否可能）

function clickOut(event) {
  event.preventDefault();
  alert('click on out');
}

function clickIn(event) {
  event.preventDefault();
  alert('click on in');
}

#out {
  width: 100px;
  height: 100px;
  border: 1px solid red;
}
#in {
  width: 50px;
  height: 50px;
  border: 1px solid blue;
}

<div id="out" onclick="clickOut(event)">
  <div id="in" onclick="clickIn(event)">
  </div>
</div>

现场演示:http://jsbin.com/qomuteyoke/1/edit？html,css,js,output

为什么当我点击内部div时,即使我打电话,仍会弹出两个警报event.preventDefault()？首先是click on in,第二是click on out？

我们可以轻松地%%%在build.sbtscalajs项目中使用,例如:

libraryDependencies +=
  "com.lihaoyi" %%% "utest" % "0.3.0" % "test"

(现场演示:https://github.com/scala-js/scala-js-pickling/blob/master/build.sbt#L92)

但是当我尝试使用project/Build.scala相同的构建文件时,它无法编译,我也不知道如何导入%%%:

import org.scalajs.sbtplugin.cross.{CrossType, CrossProject}
import sbt._
import Keys._

object Build extends sbt.Build {

  lazy val crossProject = CrossProject("server", "client", file("."), CrossType.Full)
    .settings(
      /* Shared settings */
      libraryDependencies ++= Seq(
        "io.github.widok" %%% "widok" % "0.2.1", // !!! can't compile
        "com.lihaoyi" %%% "upickle" % "0.2.6")
    )
    .jsSettings(
      /* Scala.js settings */
    )
    .jvmSettings(
      /* JVM settings */
    )

  lazy …

在"Scala中的函数式编程"一书中,有一些词汇谈论"已检查的异常":

检查异常

Java检查的异常至少会强制决定是否处理或重新报告错误,但它们会为调用者带来重要的样板.更重要的是,它们不适用于高阶函数,它们不可能知道它们的参数可能引发的特定异常.例如,考虑我们为List定义的map函数:

def map[A,B](l: List[A])(f: A => B): List[B]

这个函数显然很有用,非常通用,并且与使用已检查的异常不一致 - 我们不能为每个可能抛出的单个检查异常提供一个map版本f.即使我们想要这样做,地图甚至会知道哪些例外是可能的？这就是为什么通用代码,即使在Java中,也常常使用RuntimeException或一些常见的检查Exception类型.

我多次阅读本节,但仍不清楚为什么检查异常不适用于高阶函数.

有人可以举一些例子来说明问题吗？

我正在阅读有关scala中的类别和Functor的这篇文章:https://hseeberger.wordpress.com/2010/11/25/introduction-to-category-theory-in-scala/

在这部分:

为了保留类别结构,此映射必须保留标识映射和组合.更正式的:

F(1 _A)= 1 _F(A) ∀A∈C1

F(gοf)= F(g)οF(f)∀f:A→B,g:B→C其中A,B,C∈C1

我无法理解:F(1 _A)= 1 _F(A)

为什么正确的部分是1 _F(A)而不是F(A)？

我在其他文章中看到,Functor的身份法是:

fa.map(a => a) == fa

与1 _F(A)无关

我们可以创建一个 docker 机器--registry-mirror，例如：

docker-machine create -d virtualbox --engine-registry-mirror http://111222.m.daocloud.io mymachine

如果我们登录机器，我们会发现镜像 url 在 boot2docker 中：

$ docker-machine ssh mymachine
$ cat /mnt/sda1/var/lib/boot2docker/profile
EXTRA_ARGS='
--label provider=virtualbox
--registry-mirror http://111222.m.daocloud.io

'
CACERT=/var/lib/boot2docker/ca.pem
DOCKER_HOST='-H tcp://0.0.0.0:2376'
DOCKER_STORAGE=aufs
DOCKER_TLS=auto
SERVERKEY=/var/lib/boot2docker/server-key.pem
SERVERCERT=/var/lib/boot2docker/server.pem

并且它会在拉取图像时使用这个镜像。

但是机器创建后如何更改镜像呢？

我试图midify这个boot2docker/profile文件，但似乎没有生效。怎么做？