blocks|key|1749184|text|trait+Graph+{
++type+Node
++type+Edge
++def+end1(e:+Edge):+Node
++def+end2(e:+Edge):+Node
++def+nodes:+Set[Node]
++def+edges:+Set[Edge]
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1749185|在其他地方，我们可以静态地保证我们不会混淆来自两个不同图的节点，例如：|unstyled|1749186|def+shortestPath(g:+Graph)(n1:+g.Node,+n2:+g.Node)+=+...+|1749187|当然，如果在Graph中定义的话，这已经可以工作了，但是假设我们不能修改Graph，并且正在为它编写一个"pimp+my+library“扩展。|offset|length|style|CODE|1749188|关于第二个问题:此功能支持的类型比完全依赖的类型弱得多(有关这方面的信息，请参阅Dependently+Typed+Programming+in+Agda+)。我想我以前没见过这样的类比。|1749189|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf^0|0|0|0|6|5|10|5|0|14|11|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|11|8|@$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@$K|17|L|18|1|19]]|A|$]]|$1|Q|3|-4|5|F|7|1A|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

<pre><code>trait Graph {
 type Node
 type Edge
 def end1(e: Edge): Node
 def end2(e: Edge): Node
 def nodes: Set[Node]
 def edges: Set[Edge]
}
</code></pre>

Somewhere else we can statically guarantee that we aren't mixing up nodes from two different graphs, e.g.: 

<pre><code>def shortestPath(g: Graph)(n1: g.Node, n2: g.Node) = ... 
</code></pre>

Of course, this already worked if defined inside <code>Graph</code>, but say we can't modify <code>Graph</code> and are writing a "pimp my library" extension for it.

About the second question: types enabled by this feature are far weaker than complete dependent types (See <a href="http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf" rel="nofollow">Dependently Typed Programming in Agda</a> for a flavor of that.) I don't think I've seen an analogy before.

blocks|key|1749282|text|我的developing+a+model支持使用环境状态的声明性编程形式。细节在这里是不相关的(例如，关于回调的细节以及与Actor模型结合序列化程序的概念相似性)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1749283|相关的问题是状态值存储在散列映射中，并由散列键值引用。函数输入不变的参数，这些参数是来自环境的值，可以调用其他这样的函数，并将状态写入环境。但函数不允许从环境中读取值(因此函数的内部代码不依赖于状态更改的顺序，因此在这种意义上仍然是声明性的)。如何在Scala中输入？|1749284|环境类必须有一个重载方法，该方法输入这样一个要调用的函数，并输入该函数的参数的散列键。因此，此方法可以从散列映射调用具有所需值的函数，而无需提供对这些值的公共读取访问(因此，根据需要，拒绝函数从环境中读取值的能力)。|1749285|但是，如果这些散列键是字符串或整数散列值，则散列映射元素类型subsumes的静态类型为Any或AnyRef+(下面未示出的散列映射代码)，因此可能发生运行时不匹配，即，可以将任何类型的值放入给定散列键的散列映射中。|1749286|trait+Env+{
...
++def+callit[A](func:+Env+=>+Any+=>+A,+arg1key:+String):+A
++def+callit[A](func:+Env+=>+Any+=>+Any+=>+A,+arg1key:+String,+arg2key:+String):+A
}|code-block|syntax|javascript|1749287|尽管我没有测试以下内容，但从理论上讲，我可以在运行时使用classOf从类名中获取散列键，因此散列键是一个类名而不是字符串(使用Scala的反号在类名中嵌入字符串)。|style|CODE|1749288|trait+DependentHashKey+{
++type+ValueType
}
trait+`the+hash+key+string`+extends+DependentHashKey+{
++type+ValueType+<:+SomeType
}|1749289|这样就实现了静态类型安全。|1749290|def+callit[A](arg1key:+DependentHashKey)(func:+Env+=>+arg1key.ValueType+=>+A):+A|1749291|entityMap|0|LINK|mutability|MUTABLE|url|http://goldwetrust.up-with.com/t112p240-computers#4725|1|https://stackoverflow.com/questions/8360413/selectively-disable-subsumption-in-scala-correctly-type-list-contains|2|http://www.scala-lang.org/node/109^0|2|I|0|0|0|0|U|8|1|0|0|S|7|S|7|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1F|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|J|3|K|5|L|7|1K|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1L|8|@$A|1M|B|1N|Q|R]]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|S|3|T|5|L|7|1R|8|@]|9|@]|C|$M|N]]|$1|U|3|V|5|6|7|1S|8|@]|9|@]|C|$]]|$1|W|3|X|5|L|7|1T|8|@]|9|@]|C|$M|N]]|$1|Y|3|-4|5|6|7|1U|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]|18|$5|11|12|13|C|$14|19]]]]

I'm <a href="http://goldwetrust.up-with.com/t112p240-computers#4725" rel="nofollow noreferrer">developing a model</a> for the interoption of a form of declarative programming with environmental state. The details aren't relevant here (e.g. details about callbacks and conceptual similarity to the Actor model combined with a Serializer).

The relevant issue is state values are stored in a hash map and referenced by a hash key value. Functions input immutable arguments that are values from the environment, may call other such functions, and write state to the environment. But functions are not allowed to read values from the environment (so the internal code of the function is not dependent on the order of state changes and thus remains declarative in that sense). How to type this in Scala?

The environment class must have an overloaded method which inputs such a function to call, and inputs the hash keys of the arguments of the function. Thus this method can call the function with the necessary values from the hash map, without providing public read access to the values (thus as required, denying functions the ability to read values from the environment).

But if these hash keys are strings or integer hash values, the static typing of the hash map element type <a href="https://stackoverflow.com/questions/8360413/selectively-disable-subsumption-in-scala-correctly-type-list-contains">subsumes</a> to Any or AnyRef (hash map code not shown below), and thus a run-time mismatch could occur, i.e. it would be possible to put any type of value in a hash map for a given hash key.

<pre><code>trait Env {
...
 def callit[A](func: Env =&gt; Any =&gt; A, arg1key: String): A
 def callit[A](func: Env =&gt; Any =&gt; Any =&gt; A, arg1key: String, arg2key: String): A
}
</code></pre>

Although I didn't test the following, in theory I can get the hash keys from class names at runtime employing <a href="http://www.scala-lang.org/node/109" rel="nofollow noreferrer"><code>classOf</code></a>, so a hash key is a class name instead of a string (using Scala's backticks to embed a string in a class name).

<pre><code>trait DependentHashKey {
 type ValueType
}
trait `the hash key string` extends DependentHashKey {
 type ValueType &lt;: SomeType
}
</code></pre>

So static type safety is achieved.

<pre><code>def callit[A](arg1key: DependentHashKey)(func: Env =&gt; arg1key.ValueType =&gt; A): A
</code></pre>

blocks|key|1962780|text|当具体的abstract+type+members+are+used+instead+of+type+parameters时需要这个新功能。当使用类型参数时，family+polymorphism类型依赖关系可以在最新版本和一些较旧版本的Scala中表达，如下面的简化示例所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1962781|trait+C[A]
def+f[M](a:+C[M],+b:+M)+=+b
class+C1+extends+C[Int]
class+C2+extends+C[String]

f(new+C1,+0)
res0:+Int+=+0
f(new+C2,+"")
res1:+java.lang.String+=+
f(new+C1,+"")
error:+type+mismatch;
+found+++:+C1
+required:+C[Any]
+++++++f(new+C1,+"")
+++++++++%5E|code-block|syntax|javascript|1962782|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1154571/scala-abstract-types-vs-generics|1|http://www.daimi.au.dk/~eernst/papers/fampol.ps^0|4|1L|0|27|J|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

This new feature is needed when concrete <a href="https://stackoverflow.com/questions/1154571/scala-abstract-types-vs-generics">abstract type members are used instead of type parameters</a>. When type parameters are used, the <a href="http://www.daimi.au.dk/~eernst/papers/fampol.ps" rel="nofollow noreferrer">family polymorphism</a> type dependency can be expressed in the latest and some older versions of Scala, as in the following simplified example.

<pre><code>trait C[A]
def f[M](a: C[M], b: M) = b
class C1 extends C[Int]
class C2 extends C[String]

f(new C1, 0)
res0: Int = 0
f(new C2, "")
res1: java.lang.String = 
f(new C1, "")
error: type mismatch;
 found : C1
 required: C[Any]
 f(new C1, "")
 ^
</code></pre>

Dependent method types, which used to be an experimental feature before, has now been <a href="https://lampsvn.epfl.ch/trac/scala/changeset/25859" rel="noreferrer">enabled by default in the trunk</a>, and apparently this seems to have created <a href="http://twitter.com/#!/milessabin/status/127160650249154560" rel="noreferrer">some excitement</a> in the Scala community. 

At first look, it's not immediately obvious what this could be useful for. Heiko Seeberger posted a simple example of dependent method types <a href="https://gist.github.com/1303276#comments" rel="noreferrer">here</a>, which as can be seen in the comment there can easily be reproduced with type parameters on methods. So that wasn't a very compelling example. (I might be missing something obvious. Please correct me if so.)

What are some practical and useful examples of use cases for dependent method types where they are clearly advantageous over the alternatives? 

What interesting things can we do with them that weren't possible/easy before? 

What do they buy us over the existing type system features?

Also, are dependent method types analogous to or drawing inspiration from any features found in the type systems of other advanced typed languages such as Haskell, OCaml?

What are some compelling use cases for dependent method types?

依赖方法类型，以前是一个实验性的特性，现在已经变成了，显然这似乎在Scala社区中创建了。乍一看，这有什么用还不是一目了然。Heiko Seeberger发布了一个依赖方法类型的简单示例，可以在注释中看到，它可以很容易地在方法上使用类型参数重现。所以这不是一个很有说服力的例子。(我可能遗漏了一些明显的东西。如果是这样，...

问依赖方法类型有哪些引人注目的用例？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问依赖方法类型有哪些引人注目的用例？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问依赖方法类型有哪些引人注目的用例？
EN