设计概要
注释
// 注释
/* 注释 */
内置类型
[bool, byte, char, short, int, unit] // 值类型
[String, List, Map] // 对象
变量定义
var i: int = 0;
// 列表
var l: List<int> = [1, 2, 3, 4, 5];
l[0] = 1;
// 字典
var m: Map<int->string> = {
"a" -> 1,
"b" -> 2
}
m["a"] = 1;
// 函数
var x: int => int = (p:int) => p
函数定义
def add(a:int,b:int):int = {
return a+b;
}
first class function
def addx(x:int): int => int = {
return (a:int) => x+a;
}
类定义
class A extends B {
public/private/protected:
var a:int = 0;
// 构造函数
def A(a:int) = {
this.a = a;
}
// 成员函数
def s() = {
print(this.a);
}
}
接口
这里的接口相当于java的interface，只不过在类外实现。
- 最普通的接口
interface showable
{
def show(this:This);
}
// 为非泛型类实现trait
impl showable for int
{
def show(this:int) = {
print(this);
}
}
1.show() // 合法
// 为泛型类实现trait
template<A,B>
class Pair{
public:
def Pair(a:A, b:B) = {
this.a = a;
this.b = b;
}
var a:A;
var b:B;
}
// 全泛化
template<A,B>
impl showable for Pair<A,B>
{
def show(this) = {
print(a,b);
}
}
// 偏特化，带有泛型约束
template<A,B>
where A: extends Object impl Hash
B: extends Object impl Hash
impl showable for Pair<A,B>
{
def show(this:Pair<A,B>) = {
print(a.hashCode(),b.hashCode());
}
}
// 实体化
impl showable for Pair<int,int>
{
def show(this:Pair<int,int>) = {
print(a,b);
}
}
- 泛型接口
这里演示一个泛型接口的问题，即因为命名冲突，一个泛型接口无法被实现两次：
template<T>
interface Get
{
def get(this:This):T
}
impl Get<int> for int {
def get(this:int):int {
return this;
}
}
impl Get<String> for int {
def get(this:int):String {
return this.toString()
}
}
1.get() // ambiguous, which one to choose?
泛型接口的本质是要对接口规定方法的类型签名做出限制，但是确实存在如上的问题。
怎么解决？去掉泛型接口。但是可以用concept来绕过。
算了吧还是留着吧，反正java也这样。
concept
interface偏重扩展类的行为，而concept偏重约束类的特征。
concept必须拥有类的完全访问权？这点还是待定吧，不一定有这样的需求吧。
前面的例子：
concept Get<T,Result>
{
def get(x:T):Result;
}
instance Get<int,int>
{
def get(x:int):int = {
return x;
}
}
instance Get<int,String>
{
def get(x:int):String = {
return x.toString();
}
}
Get<int,int>::get(1); // 合法, = 1
Get<int,String>::get(2); // 合法, = "2"
完美解决。
下面看一个更一般的例子，实现一个幺半群(有满足结合律的加法和单位元)。
scala代码：
abstract class SemiGroup[A] {
def add(x: A, y: A): A
}
abstract class Monoid[A] extends SemiGroup[A] {
def unit: A
}
object ImplicitTest extends App {
implicit object StringMonoid extends Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = ""
}
implicit object IntMonoid extends Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
}
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
println(sum(List(1, 2, 3))) // uses IntMonoid implicitly
println(sum(List("a", "b", "c"))) // uses StringMonoid implicitly
}
Hint代码：
template<A>
concept SemiGroup {
def add(x: A, y: A): A
}
template<A>
concept Monoid combine SemiGroup
{
def unit():A;
}
instance SemiGroup<String> {
def add(x: String, y: String): String = {
return x+y;
}
}
instance Monoid<String>{
def unit():String {
return "";
}
}
instance SemiGroup<int> {
def add(x: int, y: int): int = {
return x+y;
}
}
instance Monoid<int>{
def unit():int{
return 0;
}
}
template<A>
where A: instance Monoid<A>
def sum(xs: List[A]): A = {
if (xs.isEmpty)
// 这里的‘Monoid’是简写形式，允许你直接使用instance限制里出现的concept
return Monoid::unit()
return Monoid::add(xs.head, sum(xs.tail))
}
可以发现二者的不同，concept偏向于短代码的组合，而没有继承链这一说。还有一个优势是，在你需要类型SemiGroup<int>这种形式的参数时，我们已经实现过它了。而目前并没有这样的隐式值。
需要注意一点，如同类继承，concept不能有循环依赖。
template <A>
concept SemiGroup
where a: instance SemiGroup // 错误！依赖自身！
{
def add(x: A, y: A): A
}
template <A>
concept SemiGroup
where a: instance Monoid<A> // 错误！循环依赖！
{
def add(x: A, y: A): A
}
template <A>
concept Monoid
where A: instance SemiGroup<A>
{
def unit():A;
}
解决方法是按声明顺序识别依赖关系，如果一个concept依赖另一个尚未声明的concept，直接报错即可。
concept结合OO
可以看到concept和泛型的abstract class功能好像是相似的，怎么解决这个问题？
解决了，concept是对类型的限制，比如Monoid[A]表明类型A满足幺半群的公理，即类型本身满足公理。而class内部定义类的数据和行为。也就是一个是外部的限制，一个是自身的行为。
template <Elem, Result, template F<_>>
concept Functor {
def fmap(x: Elem =>Result): F<Elem> => F<Result>
}
// 偏特化
template<Elem, Result>
instance Functor<Elem, Result, List<Elem>> {
override def fmap(func: Elem => Result): List<Elem> => List<Result> = {
return list => list.map(func);
// 做自动类型推导
// 等价于 return (list:List<Elem>):List<Result> => list.map(func)
}
}
// 偏特化
template<Elem, Result>
instance Functor<Elem, Result, Option<Elem>> {
override def fmap(func: Elem => Result): Option<Elem> => Option<Result> = {
return m => {
return switch m {
case null => null;
case Some(e) => Some(func(e));
}
}
}
}
// 于是
var l:List<int> = [1,2,3,4];
var f = Functor<int, String, List<int>>::fmap( x => x.toString());
// 最好能够自动推导，写成
var g = Functor::fmap( (x:int) => x.toString() )
f(l); // 结果 = ["1","2","3","4"]
想要用高阶类型不得不使用template语法。。。
template <A,B,C>
concept AddEq {
def add(x:A,y:B):C
}
instance AddEq<int,int,int> {
override def add(x:int,y:int):int = {
return x+y;
}
}
template <T>
instance AddEq<T,T,String> {
override def add(x:T,y:T):String = {
return x.toString()
}
}
template<T>
def add(x:T,y:T)
再考虑一个concept和高阶类型的区别：
// 泛型类实现
template<Elem>
class Stack {
var data:Array<T>;
var pos:int;
def Stack() {
data = new Array<T>();
}
def pop(e:Elem) {
pos = pos - 1;
}
def push(e:Elem) {
data[pos] = e;
pos = pos + 1;
}
def top():Elem {
return data[pos-1];
}
}
linq (糖
var l:List[int] = [-1,-2,0,1,2];
from a in l
from b in l
from c in l
where a > 0 && b>0 && c>0
select (a,b,c);
模式匹配 (糖
// 注意switch是语句，不是表达式
switch x {
case 1 => xxx; // 不用break
case a:string => xxx;
case A(a,b) => xxx;
default: xxx;
}
递归模板
data List a = Nil | Cons a (List a)
template <T>
type List<T> = null | Cons<T, List<T> >
项目规划
- if、while、操作符、var/val
- 类
- 继承、sealed
- 接口
- lambda
- 泛型类、泛型接口
- linq查询表达式
- case class和模式匹配
- concept
高级特性看进度考虑加入：
- 反射
- 表达式树
- 宏
- 注解
一些细节：
- typedef/typealias
- 嵌套类型、嵌套函数声明
- 模板字符串
- object
- 设计模式语法层简化
- scala类似中缀操作符的一些语法糖
