505 - HTTP Version Not Supported
505 - HTTP Version Not SupportedScala函数式编程原理的课程主页 - 网易公开课
登录网易公开课
点击将进入我们的官方合作伙伴Coursera学习，学的过程中别忘了回来参与课程讨论哦~
点击将进入我们的官方合作伙伴Coursera学习，学的过程中别忘了回来参与课程讨论哦~
还没有开课（最近开课时间：暂无开课时间）哦！先在“课程讨论”看看大家的帖子，或说说自己对本课程的期待。
学习函数式编程以及如何有效地将函数式编程与面向对象编程结合起来。使用斯卡拉编程语言，编写清晰的函数代码。
课程概述 本课程使用Scala编程语言介绍函数式编程的基础。近年来，函数式编程越来越受欢迎，因为它提高了代码的安全性，使其更简洁和优雅。此外，函数式编程可以通过定义和构建函数，强制替代可变变量和循环，使得当前和未来的多处理器并行代码编写越来越简单，从而能够定义并构建函数。 Scala是一种将函数式编程和面向对象编程结合为实用程序包的语言。它与Java及其工具实现了无缝互用。如今，使用Scala的开源项目和企业数量快速增长。它为许多网站提供核心基础设施，例如推特（Twitter）、邻客音（LinkedIn）、四方网（Foursquare）、汤博乐（Tumblr）和 Klout。 本节课上，你将会学到函数式编程模式的基本原理以及如何将它们正确应用于日常编程任务中。通过对不变量的证明和跟踪符号化执行过程，你也将会在函数式程序推理方面打下牢固的基础。本课程为亲自动手课程，大多数单元将会使用较短的程序作为示例，解释一些重要的概念。你可以随意操作、修改和改善这些程序。本课程还提供一系列任务作为补充，大多数都是编程项目。
课程大纲 第一周：编程范例，函数式编程与Scala编程语言概述
第二周：定义并使用函数，递归函数以及非终止函数，将函数作为值进行处理，归约推理。
第三周：定义并使用不可变对象，回顾继承与动态绑定。
第四周：类型与模式匹配
第五周：使用列表
第六周：集合与组合搜索
第七周：延迟计算
背景知识 你应该有至少一年的编程经验。精通Java或C#尤佳 ，但有其他语言，例如C/C++、Python、Javascript或Ruby等相关经验亦可。
参考资料 课程已经涵盖了本领域相关内容。为了更深入理解课程中的某些理念，推荐阅读， 作者是阿尔贝森和萨斯曼，MIT出版社出版。想要了解更多有关Scala的信息，推荐阅读，作者是奥德斯基、斯布和凡纳斯，Artima出版社出版，或者 ，作者是霍斯特曼，艾迪生韦斯利出版社出版。
授课形式 本门课由视频课程构成，时长为6到15分钟。每段视频中均有相应的测验问题。除此之外， 我们还会布置单独的作业。
学完这门课程后我会得到证书吗？
会的。顺利完成本课程的学生会得到由教师签名的结业证书。
学习本课程需要哪些资源？
你需要安装以下软件：- Java 虚拟机JDK1.6或更高版本。- Scala 2.9或更高版本。本课程推荐开发环境为适用于Eclipse的Scala IDE。它包括在Scala安装包内，所以如果你打算只使用Eclipse环境，就只需要安装Scala IDE即可。
如果我学习了这门课程，最大的收获将会是什么？
编写出第一次运行就能正常工作的优雅代码。
了解Coursera谁有scala视频课程？_百度知道
谁有scala视频课程？
我有更好的答案
按默认排序
我有，采纳我我给你qq发给你
其他类似问题
scala的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Scala教程：类型基础 - ImportNew
英文原文: ，翻译： -
这一节的内容包含：
什么是静态类型？为什么它们很有用？
根据Picrce的说法：“类型系统是一个可以根据代码段计算出来的值对它们进行分类，然后通过语法的手段来自动检测程序错误的系统。”
类型可以让你表示函数的域和值域。例如，在数学里，我们经常看到下面的函数：
这个定义告诉我们函数”f”的作用是把实数集里的数映射到自然集里。
抽象地说，这才是具体意义上的类型。类型系统给了我们一些表示这些集合的更强大的方式。
有了这些类型标识，编译器现在可以 静态地(在编译期)判断这个程序是正确的。换句话说，如果一个值（在运行期）不能够满足程序里的限制条件的话，那么在编译期就会出错。
通常来说，类型检测器(typechecker)只能够保证不正确的的程序不能通过编译。但是，它不能够保证所有正确的程序都能通过编译。
由于类型系统的表达能力不断增加，使得我们能够生成出更加可靠的代码，因为它使得我们能够控制程序上的不可变，即是是程序还没有运行的情况下（在类型上限制bug的出现）。学术界一直在努力突破类型系统的表达能力的极限，包含值相关的类型。
注意，所有的类型信息都会在编译期擦除。后面不再需要。这个被称为类型擦除。
Scala中的类型
Scala强大的类型系统让我们可以使用更具有表现力的表达式。一些主要的特点如下：
支持参数多态，泛型编程
支持（局部）类型推导，这就是你为什么不需要写val i: Int = 12: Int
支持存在向量(existential quantification)，给一些没有名称的类型定义一些操作
支持视图。 我们下个星期再讨论；给定的值从一个类型到其他类型的“可转换性”
多态可以用来编写泛型代码（用于处理不同类型的值)，并且不会减少静态类型的表达能力。
例如，没有参数多态的话，一个泛型的列表数据结构通常会是下面这样的写法（在Java还没有泛型的时候，确实是这样的）：
scala& 2 :: 1 :: &bar& :: &foo& :: Nil
res5: List[Any] = List(2, 1, bar, foo)
这样的话，我们就不能够恢复每个元素的类型信息。
scala& res5.head
res6: Any = 2
这样一来，我们的应用里会包含一系列的类型转换(“asInstanceOf[]“)，代码会缺少类型安全（因为他们都是动态类型的）。
多态是通过指定类型变量来达到的。
scala& def drop1[A](l: List[A]) = l.tail
drop1: [A](l: List[A])List[A]
scala& drop1(List(1,2,3))
res1: List[Int] = List(2, 3)
多态是scala里的一等公民
简单来说，这意味着有一些你想在Scala里表达的类型概念会显得“太过于泛型”，从而导致编译器无法理解。假如你有这样一个函数：
def toList[A](a: A) = List(a)
你想要按照泛型的方式来使用它：
def foo[A, B](f: A =& List[A], b: B) = f(b)
但是这样会编译不过，因为所有的类型变量在运行期必须是确定的。
def foo[A](f: A =& List[A], i: Int) = f(i)
…you get a type mismatch.
…你会看到一个类型不匹配的错误
对于静态类型的一个比较常见的缺陷就是有太多的类型语法。Scala提供了类型推导来解决这个问题。
函数式语言里比较经典的类型推导的方法是 Hindlry-Milner，并且它是在ML里首先使用的。
Scala的类型推导有一点点不同，不过思想上是一致的：推导所有的约束条件，然后统一到一个类型上。
在Scala里，例如，你不能这样写：
scala& { x =& x }
:7: error: missing parameter type
{ x =& x }
但是在OCaml里，你可以:
# fun x -&;
- : 'a -& 'a =
在Scala里，所有的类型推导都是局部的。Scala一次只考虑一个表达式。例如：
scala& def id[T](x: T) = x
id: [T](x: T)T
scala& val x = id(322)
x: Int = 322
scala& val x = id(&hey&)
x: java.lang.String = hey
scala& val x = id(Array(1,2,3,4))
x: Array[Int] = Array(1, 2, 3, 4)
在这里，类型都被隐藏了。Scala编译器自动推导参数的类型。注意我们也没有必要显示指定返回值的类型了。
Scala的类型系统需要把类的继承关系和多态结合起来。类的继承使得类之间存在父子的关系。当把面向对象和多态结合在一起时，一个核心的问题就出来了：如果T'是T的子类，那么Container[T']是不是Container[T]的子类呢？Variance注释允许你在类继承和多态类型之间表达下面的这些关系：
Scala中的标记
covariant(协变)
C[T’]是C[T]的子类
contravariant(逆变)
C[T]是C[T’]子类
invariant(不变)
C[T]和C[T’]不相关
子类关系的真正意思是：对于一个给定的类型T，如果T’是它的子类，那么T’可以代替T吗？
scala& class Contravariant[-A]
defined class Contravariant
scala& val cv: Contravariant[String] = new Contravariant[AnyRef]
cv: Contravariant[AnyRef] = Contravariant@49fa7ba
scala& val fail: Contravariant[AnyRef] = new Contravariant[String]
:6: error:
: Contravariant[String]
required: Contravariant[AnyRef]
val fail: Contravariant[AnyRef] = new Contravariant[String]
逆变(Contravariance)看起来比较奇怪。什么时候要用到它呢？确实让人感到惊讶！
trait Function1 [-T1, +R] extends AnyRef
如果你从替代的角度来看这个的话，非常容易理解这一点。我们首先来定义一个简单的类继承关系：
scala& class Animal { val sound = &rustle& }
defined class Animal
scala& class Bird extends Animal { override val sound = &call& }
defined class Bird
scala& class Chicken extends Bird { override val sound = &cluck& }
defined class Chicken
假设你需要一个接收Bird类型参数的函数：
scala& val getTweet: (Bird =& String) = // TODO
标准的animal类库有一个函数可以完成你想要的任务，但是它的参数是Animal。在大部分的场景下，如果你说“我需要一个，我有一个的子类”，这样是可以的。但是函数的参数都是可逆变的（contravariant），如果你需要一个接受一个Bird的函数，并且你有一个接收一个Chicken的函数，这个函数会卡在Duck上。但是一个接收Animal作为参数的函数就没有问题：
scala& val getTweet: (Bird =& String) = ((a: Animal) =& a.sound )
getTweet: Bird =& String =
函数的返回值是可逆变的。如果你需要一个返回Bird的函数，但是你只有一个返回Chicken的函数，这样也是可以的。
scala& val hatch: (() =& Bird) = (() =& new Chicken )
hatch: () =& Bird =
范围(Bounds)
Scala允许你通过 bounds 来限制多态的范围。这些范围表示的是子类的关系。
scala& def cacophony[T](things: Seq[T]) = things map (_.sound)
:7: error: value sound is not a member of type parameter T
def cacophony[T](things: Seq[T]) = things map (_.sound)
scala& def biophony[T &: Animal](things: Seq[T]) = things map (_.sound)
biophony: [T &: Animal](things: Seq[T])Seq[java.lang.String]
scala& biophony(Seq(new Chicken, new Bird))
res5: Seq[java.lang.String] = List(cluck, call)
还可以支持更低的类型范围；它们可以通过逆变(contravariance)和合适的协变（covariance）来实现。List[+T]是协变量；一个Bird的列表同时也是一个Animal的列表。List定义了一个操作符::[elem T]返回一个装载elem的列表。这个新的List和原来的列表有着相同的类型：
scala& val flock = List(new Bird, new Bird)
flock: List[Bird] = List(Bird@7e1ec70e, Bird@169ea8d2)
scala& new Chicken :: flock
res53: List[Bird] = List(Chicken@56fbda05, Bird@7e1ec70e, Bird@169ea8d2)
List 同时 也定义了::[B &: T]，它返回一个List[B]。注意B &: T，它表示T的父类。这个会在我们把一个Animal添加到一个List[Bird]的时候提醒我们进行纠正。
scala& new Animal :: flock
res59: List[Animal] = List(Animal@11f8d3a8, Bird@7e1ec70e, Bird@169ea8d2)
注意返回的类型是Animal。
量化（Quantification）
有时候你不需要给一个类型变量以名称，例如
scala& def count[A](l: List[A]) = l.size
count: [A](List[A])Int
你可以用“通配符”来替代：
scala& def count(l: List[_]) = l.size
count: (List[_])Int
这个可以替代：
scala& def count(l: List[T forSome { type T }]) = l.size
count: (List[T forSome { type T }])Int
注意量化（quantification）可能会显得比较诡异：
scala& def drop1(l: List[_]) = l.tail
drop1: (List[_])List[Any]
突然之间我们丢失了类型信息！为了一探究竟，我们来看看最原始的语法：
scala& def drop1(l: List[T forSome { type T }]) = l.tail
drop1: (List[T forSome { type T }])List[T forSome { type T }]
我们不能说明T的任何信息，因为在这里的类型不允许。
你也可以对通配符类型使用范围来进行限定：
scala& def hashcodes(l: Seq[_ &: AnyRef]) = l map (_.hashCode)
hashcodes: (Seq[_ &: AnyRef])Seq[Int]
scala& hashcodes(Seq(1,2,3))
:7: error:
required: AnyRef
Note: primitive types are not implicitly converted to AnyRef.
You can safely force boxing by casting x.asInstanceOf[AnyRef].
hashcodes(Seq(1,2,3))
scala& hashcodes(Seq(&one&, &two&, &three&))
res1: Seq[Int] = List(486)
参考 D. R. MacIver的
英文原文: ，翻译： -
译文链接：
【如需转载，请在正文中标注并保留原文链接、译文链接和译者等信息，谢谢合作！】
关于作者：
Java开发工程师，业余翻译
微信关注: ImportNew
分享Java相关的技术文章、工具资源和热点资讯。扫描加关注，碎片时间提高Java开发技能！
不过这不能算作保留的内存空间，from 和 to这两块空间都应回归为young space。所以说y...
Finneen Chiong
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
新浪微博：
微信号：importnew
反馈建议：@
广告与商务合作QQ：
& 2015 ImportNew}