为什么不叫@Before(Why isn't @Before being called)

 Scala到Haskell程序员： 
 
 Scala是一个严格和不纯的语言与一流的模块。 新类型被声明为模块（“类”/“特征”，具有微妙的差异）。 模块可以是采用通用量化类型参数的类型构造函数。 模块具有由值，可变变量和函数（称为“方法”）组成的成员，模块被隐式传递给其中称为this变量）。 模块可以具有也可以参数的类型成员。 类型成员是存在量化的，类型参数可以更高。 因为类型可以是第一类值的成员，所以Scala提供称为依赖路径的依赖类型的风格。 
 
 一流的功能也是模块。 一个函数是一个名为apply的方法。 一种方法不是一流的，但是提供了一种语法来将一个方法包装在一类函数中。 不幸的是，模块需要所有的类型参数，因此部分应用的一级函数不允许被普遍量化。 更一般地说，Scala完全缺乏一种等级高于1的直接机制，但是可以利用更高种类的参数化模块来模拟秩n类型。 
 
 而不是具有全局范围的类型类，Scala可以声明任何给定类型的隐式值。 这包括功能类型，提供隐式转换，因此提供类型扩展。 除了隐式转换，类型扩展由“扩展”机制提供，它允许您在模块之间声明子类型/超类型关系。 该机制可用于模拟代数数据类型，其中可以将超类型视为数据声明左侧的类型，其子类型作为右侧的值构造函数。 这也意味着ADT并不真正关闭。 Scala具有广泛的模式匹配功能，使用具有一流模式的虚拟化模式匹配器。 
 
 Scala支持子类型，这大大限制了类型推断。 但是推论的类型随时间的推移有所改善。 支持较高种类的推论。 然而，Scala缺乏有意义的系统，因此没有任何推断，也没有任何形式的统一。 如果引入了一个类型变量，它是一种*除非另有注释。 某些类型，如Any （所有类型的超类型）和Nothing （每种类型的子类型）在技术上都是各种类型，尽管它们不能应用于类型参数。 
 
 Haskell到Scala程序员： 
 
 Haskell是纯功能语言。 这意味着功能根本不允许有任何副作用。 例如，Haskell程序不会打印到屏幕上，而是返回IO[_]数据类型的值的函数，该数据类型描述IO子系统执行的一系列操作。 
 
 而Scala默认是严格的，并为非限制函数参数提供“by-name”注释，Haskell默认使用“by-need”语义进行懒惰，并为严格参数提供注释。 
 
 Haskell中的类型推断比Scala更完整，具有完全推断，即使是部分应用的多态类型构造函数。 这意味着类型注释几乎不是必需的。 
 
 最近对GHC编译器的扩展允许在Scala中没有等价的高级类型系统功能，例如rank-n类型，类型族和多种类型。 
 
 在Haskell中，模块是类型和函数的集合，但模块不是一流实体。 Implicits由类型类提供，但一旦声明为全局范围，并且它们不能像Scala一样显式传递。 给定类型的给定类型的多个实例由新类型机制解析，而在Scala中，这将通过范围界定或通过明确传递实例来解决。 
 
 由于Haskell不是“面向对象”，所以没有方法/功能的二分法。 每个函数都是第一类，默认情况下每个函数都是curried（没有Function1，Function2等）。 

Scala To a Haskell programmer:
 
Scala is a strict and impure language with first-class modules. Data types are declared as "classes" or "traits" with subtle differences, and modules or "objects" are values of those types. Scala supports type constructors taking universally quantified type parameters. Objects/classes/traits have members which consist of values, mutable variables, and functions (called "methods", to which the module is implicitly passed as a variable called this). Modules may have type members which can also take parameters. Type members are existentially quantified and type parameters can be higher-kinded. Because types can be members of first-class values, Scala provides a flavour of dependent typing called path-dependent types.
 
First-class functions are also modules. A function is a module with a method named apply. A method is not first-class, but a syntax is provided to wrap a method in a first-class function. Unfortunately, a module requires all of its type parameters up front, hence a partially applied first-class function is not allowed to be universally quantified. More generally, Scala completely lacks a direct mechanism for types of rank higher than 1, but modules parameterized on higher-kinded types can be exploited to simulate rank-n types.
 
Instead of type classes with global scope, Scala lets you declare an implicit value of any given type. This includes function types, which provides implicit conversion, and therefore type extension. In addition to implicit conversions, type extension is provided by the "extends" mechanism which lets you declare a subtype/supertype relation among modules. This mechanism can be used to simulate algebraic datatypes where the supertype can be seen as the type on the left-hand side of a data declaration, and its subtypes as the value constructors on the right-hand side. Scala has extensive pattern-matching capabilities using a virtualized pattern matcher with first-class patterns.
 
Scala supports subtyping, and this limits type inference considerably. But type inference has improved over time. Inference of higher kinded types is supported. However, Scala lacks any meaningful kind system, and therefore has no kind inference and no kind unification. If a type variable is introduced, it is of kind * unless annotated otherwise. Certain types like Any (the supertype of all types) and Nothing (a subtype of every type) are technically of every kind although they cannot be applied to type arguments.
 
Haskell to a Scala programmer:
 
Haskell is a purely functional language. This means that functions are not allowed to have any side-effects at all. For example, a Haskell program doesn't print to the screen as such, but is a function that returns a value of the IO[_] datatype which describes a sequence of actions for the IO subsystem to perform.
 
Whereas Scala is strict by default and provides "by-name" annotation for nonstrict function arguments, Haskell is lazy by default using "by-need" semantics, and provides annotation for strict arguments.
 
Type inference in Haskell is more complete than in Scala, having full inference. This means that type annotation is almost never necessary.
 
Recent extensions to the GHC compiler allow advanced type system features that have no equivalent in Scala, such as rank-n types, type families, and kinds polymorphism.
 
In Haskell, a module is a collection of types and functions, but modules are not first-class entities. Implicits are provided by type classes, but these are globally scoped once declared, and they cannot be passed explicitly as in Scala. Multiple instances of a type class for a given type are resolved by wrapping with a newtype to disambiguate, whereas in Scala this would be solved simply by scoping or by passing instances explicitly.
 
Since Haskell isn't "object-oriented", there's no method/function dichotomy. Every function is first class and every function is curried by default (no Function1, Function2, etc).
 
Haskell has no subtype mechanism, but type classes can have a subclass relationship.