Language on boboboker~

泛型

Fri, 16 May 2025 00:00:00 +0800

泛型

泛型(Generic)是非常重要的语言功能，广泛应用于各种项目、工具、框架。
本文主要关注泛型的应用，由浅入深介绍和讨论能力和限制，给出相关示例来演示应用。

演示代码语言/平台采用最新LTS或主流支持版本，详细情况如下：

C# 12 on .NET 8 (LTS)

F# 8 on .NET 8 (LTS)

Java 21 on JDK 21 (LTS)

Scala 3.3.x (LTS) on JDK 21 (LTS)

Scala 2.13.x on JDK 21 (LTS)

Python 3.13.x

.NET版本支持策略参考官方文档: .NET Support Policy; C#和F#随.NET一同发布/更新

Scala与JDK兼容情况可参考官方介绍: JDK Compatibility
Scala 2.x 维护计划在Scala 2 maintenance plans及Scala development guarantees中有介绍，简言之2.13将持续维护，2.12将在sbt 1广泛应用期间持续维护
Scala 2.13相对与2.12的变化可参考: Migrating a Project to Scala 2.13’s Collections, Scala 2.13.0 is now available!, Releases / Scala 2.13.0
Scala 3相对于2的变化可参考: Scala 3 Migration Guide

Python的版本支持情况可参考官方介绍: Status of Python versions

基本语法

本节简要介绍泛型在各语言中的基本使用。

C#

官方文档: \

Generics in .NET

C# specifications / Types / Constructed types

Generic classes and methods

……

泛型接口、泛型类和泛型方法

如下代码演示了泛型接口、泛型类、泛型方法(实例方法及静态方法)的定义和调用。\

Generic Classes (C# Programming Guide)

Generic Interfaces (C# Programming Guide)

Generic methods (C# programming guide)

// ==========[定义泛型]==========

// 定义泛型接口
interface IWritable<T>
{
    void Write(T value);
}
interface IReadable<T>
{
    T Read();
    // 接口自带默认实现
    string ReadString() => Read().ToString();
}

// 定义泛型类(并实现泛型接口)
class Response<T> : IReadable<T>, IWritable<T>
{
    public int Code { get; set; }
    public string Message { get; set; }
    // Data属性是个泛型属性
    public T Data { get; set; }

    // 构造器方法
    public Response() { }
    public Response(int code, string message, T data) : this()
    {
        this.Code = code;
        this.Message = message;
        this.Data = data;
    }
    // 解构方法
    public void Deconstruct(out int code, out string message, out T data)
    {
        code = Code;
        message = Message;
        data = Data;
    }

    // 实现泛型接口中定义的方法
    public T Read() => Data;
    public void Write(T value) => Data = value;

    // 定义泛型实例方法
    public bool TryRefreshData<U>(U data)
    {
        if (data is T t)
        {
            this.Data = t;
            return true;
        }
        return false;
    }

    // 尽量避免在泛型类中定义静态方法，调用相对比较麻烦
    // 定义泛型静态方法
    public static Response<U> Success<U>(U data)
        => new(0, "success", data);
    // 定义静态方法
    public static Response<string> Failed(string message)
        => new(1, message, "failed");
}

// 定义工具类
// C#中，泛型静态方法最好放在单独的工具类中，可以直接以
class ResponseHelper
{
    // 定义泛型静态方法
    public static Response<T> Success<T>(T data)
        => new(0, "success", data);
    public static Response<string> Failed(string message)
        => new(1, message, "failed");
}

// 定义(静态)扩展类
static class ResponseExtension
{
    // 定义泛型扩展方法
    public static Response<T> Copy<T>(this Response<T> response)
        => new(response.Code, response.Message, response.Data);
    // 定义泛型扩展方法
    public static bool IsSuccess<T>(this Response<T> response)
        => response.Code == 0;
}

// ==========[使用泛型]==========
// 初始化对象(调用构造器)
var response = new Response<string>(0, "success", "data");
// 初始化对象(属性初始化)
var response = new Response<string>
{
    Code = 0,
    Message = "success",
    Data = "data"
};
// 初始化对象(new表达式)
Response<string> response = new(0, "success", "data");
// 解构对象
var (code, _, data) = response;

// 泛型方法调用时，编译器可以从参数中推断类型，因此一般无需声明类型

// 调用泛型实例方法
response.TryRefreshData(123);
// 调用泛型实例方法(声明类型)
response.TryRefreshData<short>(123);

// 调用静态泛型方法
// 调用泛型类中的静态方法时，必须要声明泛型类的具体类型(泛型静态方法的类型一般无需声明)
var response = Response<string>.Success<short>(123);
// 调用普通工具类中的静态方法(泛型静态方法的类型一般无需声明)
var response = ResponseHelper.Success<short>(123);

// 调用泛型扩展方法(与实例方法调用语法一致)
var success = response.IsSuccess();
var copy = response.Copy();

泛型接口、泛型类、泛型方法算是面向对象编程中对泛型最基本的应用。
此外泛型抽象类并未因泛型而新增特殊之处，其本身的功能及限制只是因为它是“抽象类”而非“泛型”，因此代码中并未演示。

泛型委托和泛型事件

委托和事件C#独有的语言功能，两者皆支持泛型，此处演示相关应用。相关详细概念请参考官方文档。

Generic Delegates (C# Programming Guide)

Delegates (C# Programming Guide)

Events (C# Programming Guide)

// 定义泛型委托
delegate T BiOp<T>(T a, T b);

// 使用泛型委托
BiOp<int> add = (a, b) => a + b;
var c = add(1, 2);

class Singleton<T>
{
    // 定义事件
    public event EventHandler<T> ValueChanged;

    private T _value;
    public T Value 
    { 
        get => _value;
        set
        {
            if (!EqualityComparer<T>.Default.Equals(Value, value))
            {
                _value = value;
                OnValueChanged(value);
            }
        }
    }

    protected virtual void OnValueChanged(T value)
    {
        // 触发事件
        ValueChanged?.Invoke(this, value);
    }
}

// 初始化对象
var singleton = new Singleton<int>();
// 订阅事件(多个事件处理程序)
singleton.ValueChanged += (_, i) => Console.WriteLine($"int = {i}");
// 赋值&触发事件
singleton.Value = 1;
// 重复赋值&不触发事件
singleton.Value = 1;

事件本质上是特殊类型的委托。对两者的深入探讨请参考官网文档。、

Introduction to delegates

Introduction to events

Distinguishing Delegates and Events

泛型数组

Generics and Arrays (C# Programming Guide)

泛型数组本身没什么特殊，此处需要特别注明的是一维数组自动实现IList<T>接口，这有助于实现一个泛型方法对数组或其他集合进行遍历。
但要注意自动实现的IList<T>接口仅支持数据读取，不能用于从数组中增删元素(会抛出异常)。

// 直接以集合初始化语法定义并初始化数组和List
int[] array = [1, 2, 3, 4, 5];
List<int> list = [1, 2, 3, 4, 5];

// 以一致的方式访问(读取)数组和List
ProcessItems(array);
ProcessItems(list);

static void ProcessItems<T>(IList<T> list)
{
    // 数组对象调用IsReadOnly返回True,List对象会返回False
    Console.WriteLine("IsReadOnly returns {0} for this collection.", list.IsReadOnly);

    // 对数组对象调用Insert/RemoveAt方法会导致抛出异常
    //list.RemoveAt(4);

    foreach (T item in list)
    {
        Console.Write(item?.ToString() + " ");
    }
    Console.WriteLine();
}

F#

TBD

Java

泛型约束

泛型约束声明了类型参数预期的能力，声明约束后可以安全地调用支持的操作。

C#

Constraints on type parameters (C# Programming Guide)

C#具备种类丰富的泛型约束，下方列表中对各种类型进行简要介绍。

泛型约束	简介
`where T : struct`	`T`必须是不可为NULL的值类型(Value Type)(可以是`record struct`类型)。由于所有值类型必定存在可用的无参构造器，因此这也隐含声明`new()`约束。 `struct`约束不能与`new()`及`unmanaged`约束组合使用。
`where T : class`	`T`必须是引用类型(Reference Type)。 `T`可以是类、记录类(record class)、接口、委托、数组。在允许为NULL上下文(nullable context)中，`T`必须是不可为NULL的引用类型。
`where T : class?`	`T`必须是引用类型(Reference Type)，可以是允许为NULL的引用类型，也可以是不允许为NULL的引用类型。 `T`可以是类、记录类(record class)、接口、委托、数组。
`where T : notnull`	`T`必须是不可为NULL的类型。 `T`可以是不可为NULL的引用类型、不可为NULL的值类型。
`where T : unmanaged`	`T`必须是不可为NULL的非托管类型(Unmanaged Type)。 `unmanaged`约束隐含声明`struct`，不能与`struct`及`new()`约束组合使用。注：非托管类型包括内置值类型及布尔类型、枚举类型、指针类型、成员都是非托管类型的元组(tuple)和结构(struct)类型。但该约束依然不允许指针和可为NULL的非托管类型。
`where T : new()`	`T`必须有公开的无参构造器。当与其他约束组合使用时，`new()`约束必须放在最后。 `new()`约束不能与`struct`及`unmanaged`约束组合使用。
`where T : <class name>`	`T`必须是给定的类或继承自给定的类。在允许为NULL上下文(nullable context)中，`T`必须是不可为NULL的引用类型。
`where T : <class name>?`	`T`必须是给定的类或继承自给定的类。在允许为NULL上下文(nullable context)中，`T`可以是允许为NULL的引用类型，也可以是不允许为NULL的引用类型。
`where T : <interface name>`	`T`必须是给定的接口或实现了给定的接口。可以声明多个接口约束；约束中给定的接口也可以是泛型接口。在允许为NULL上下文(nullable context)中，`T`必须是实现给定接口的不允许为NULL的类型。
`where T : <interface name>?`	`T`必须是给定的接口或实现了给定的接口。可以声明多个接口约束；约束中给定的接口也可以是泛型接口。在允许为NULL上下文(nullable context)中，`T`必须是实现给定接口的可为NULL引用类型、不可为NULL的引用类型、值类型。`T`不可以是允许为NULL的值类型。
`where T : U`	`T`必须是类型参数`U`给定的类型或继承自给定类型。在允许为NULL上下文(nullable context)中，若`U`是不允许为NULL的引用类型，则`T`也必须是不可为NULL的引用类型；若`U`是允许为NULL的引用类型，则不限制`T`是否可为NULL。
`where T : default`	`T`必须未声明`struct`或`class`约束。该约束仅在显式实现接口方法或重写方法时可用，用于声明期望实现/重写的是`T`未被约束的方法。
`where T : allows ref struct`	该反约束允许`T`是`ref struct`类型。 `T`可能是`ref struct`实例，泛型类型和方法必须遵循引用安全规则(ref safety rules)。 C# 13.0+可用

某些约束是互斥的，某些约束必须遵循特定的顺序。

struct/class/class?/notnull/unmanaged约束至多允许一个，且必须是第一个约束；
基类约束(where T : Base/where T : Base?)至多允许一个，使用where T : Base?支持可为NULL的基类，基类约束不能与struct/class/class?/notnull/unmanaged约束组合使用；
不允许同时声明单个接口的可NULL和不可NULL形式(where T : I1, I1? ×; where T : I1, I2? √)；
new()约束不能与struct/unmanaged约束组合使用；若存在new()约束，其必须位于约束的最后(反约束可以放在它后面)；
default约束只能用于方法重写和显式实现接口方法场景，且不能与struct/class约束组合使用；
反约束allows ref struct不能与class/class?约束组合使用，且必须跟在所有约束的后面。

部分约束有如下注意事项。\

使用class约束时避免使用比较操作符==/!=。这组操作符只比较引用是否相等，不进行值比较。该行为不会因具体类型是否重载比较操作符而变化，因为编译时仅能得知类型是引用类型，必须调用对所有引用类型都合法有效的实现。若要在泛型代码中进行值比较，请使用where T : IComparable<T>或where T : IEquatable<T>约束并为实际类型实现相关接口。
若类型参数没有任何约束(例如SampleClass<T>{}中的T)称为未绑定类型(unbounded type parameter)，应当遵循如下规则：
- 不能使用比较操作符==/!=，因为不能保证实际类型支持该操作符；
- 可以显式转换为任何接口类型，也可以转换成System.Object类型(或者由System.Object转换成T)；
- 可以与null进行比较(T是值类型时会返回false)
notnull约束用以声明类型参数将约束为不可为NULL的值类型/引用类型，违反notnull约束时，编译器只会生成警告，不会报告错误。notnull约束仅在可空代码上下文中生效，若在忽略可空性的代码上下文使用，违反约束时编译器不会生成任何警告或错误。

以下对部分约束进行详细解释及代码演示。

泛型约束常规应用

// 单个类型参数的泛型约束
struct Container<T> where T : struct
{
    public T Value { get; set; }
}

// 多个类型参数的泛型约束(各自约束互不干涉)
class Container<K, V>
    where K : struct
    where V : class, new()
{
    // ...
}

// 类型参数作为约束
class SampleClass<T, U, V> where T : V { }
class List<T>
{
    public void Add<U>(List<U> items) where U : T {/*...*/}
}

`default`约束

参考文档: dotnet/csharplang/proposals/csharp-9.0/unconstrained-type-parameter-annotations

default约束是用于在重写/实现方法时消除nullable泛型重载的歧义。以下以代码演示其功能。

关于`?`标注

C# 8.0中，?仅能用于显式约束了值类型或引用类型的类型参数；在C# 9.0中，?可以用于任意类型参数，无论是否存在约束。
但要注意，?标注仅能用于设置了#nullable enable的代码上下文中。

若是类型参数T是个引用类型，T?表示该引用类型的可NULL实例。

1
2

var s1 = new string[0].FirstOrDefault();  // string? s1
var s2 = new string?[0].FirstOrDefault(); // string? s2

若是类型参数T是个值类型，T?表示该值类型的实例。

1
2

var i1 = new int[0].FirstOrDefault();  // int i1
var i2 = new int?[0].FirstOrDefault(); // int? i2

若是类型参数T是其他标注过的类型U?，T?依然表示标注过的类型U?，而不是U??。

1
2

var u1 = new U[0].FirstOrDefault();  // U? u1
var u2 = new U?[0].FirstOrDefault(); // U? u2

若是类型参数T是其他类型U，T?表示标注过的类型U?，即使在#nullable disable上下文中。

1
2

#nullable disable
var u3 = new U[0].FirstOrDefault();  // U? u3

实际上T?仅是个标注，并非一定是在构造新类型。
FirstOrDefault方法的声明是public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source);，返回值部分只是声明可能为NULL，并不是将返回值变成真正的可空类型TSource?。
对于值类型TSource(如int)，TSource?和TSource在IL中都是int，方法泛型返回值不能为int标注?(int?实际是Nullable<int>，是个新结构)。
对于返回值，T?等同于[MaybeNull] T，对于参数值，T?等同于[AllowNull] T。当重写方法或实现接口时该等同性非常重要。
以下代码演示了该等同性。

public abstract class A
{
    // 以特性方式声明抽象方法
    // 没有声明`class`/`struct`约束，编译器认为存在歧义，会添加`where T : default`约束

    // 实际等同于public abstract T? F1<T>(); (也会默认添加where T : default约束)
    [return: MaybeNull] public abstract T F1<T>();
    // 实际等同于public abstract void F2<T>(T? t)
    public abstract void F2<T>([AllowNull] T t);
}

public class B : A
{
    // 重写时必须显式声明where T : default约束
    public override T? F1<T>() where T : default { return defalut(T); } // matches A.F1<T>()
    public override void F2<T>(T? t) where T : default {  }             // matches A.F2<T>()
}

使用T?或注解形式的可为NULL声明且不存在class/struct约束时，编译器认为存在歧义，会默认添加where T : default约束，表示没有约束class/struct。
方法重写/实现接口时，必须声明where T : default约束，用来表示重写/实现的是不约束class/struct的方法。\

关于歧义

参考如下代码，除泛型约束外，两个方法是一致的形式，但方法签名不包含泛型约束信息。理论上，两个方法不应同时存在。

class C
{
    public virtual void F<T>(T? t) where T : struct { }
    public virtual void F<T>(T? t) where T : class { }
}

实际上，以上代码是合法的，两个方法是不同的签名。

C#8.0引入可为NULL引用类型支持，T?的意义取决于T是值类型或是引用类型。

泛型约束	`T?`的含义	真实参数类型
`where T : struct`	可为NULL值类型	`Nullable<T>`
`where T : class`	可为NULL引用类型	`T`(带可为NULL元数据)

以上代码在编译器视角中的实际形式如下。

using System.Diagnostics.CodeAnalysis;

class C
{
    public virtual void F<T>(Nullable<T> t) where T : struct { }
    public virtual void F<T>([AllowNull] T t) where T : class { }
}

两个方法的参数在编译器视角中是不同的类型，函数签名不同，因此可以同时存在。
但是对常规写法而言，用户读到的代码是一样的，因此便出现了歧义。

消除歧义

显式class/struct约束的代码，重写/实现时可以通过显式约束消除歧义。

class A1
{
    public virtual void F1<T>(T? t) where T : struct { }
    public virtual void F1<T>(T? t) where T : class { }
}

class B1 : A1
{
    public override void F1<T>(T? t) /*where T : struct*/ { }
    public override void F1<T>(T? t) where T : class { }
}

注: 显式struct约束的方法参数实际是Nullable<T>，相对于参数为T的方法，这是个约束更强(更具体)的版本，在编译器解析时具备更高的优先级。
因此重写方法时的where T : struct约束可以省去，但非常不建议这样做。

而当存在有约束和无约束版本的方法时，可以使用default约束来消除歧义。

class A2
{
    public virtual void F2<T>(T? t) where T : struct { }
    public virtual void F2<T>(T? t) { }
}

class B2 : A2
{
    public override void F2<T>(T? t) /*where T : struct*/ { }
    public override void F2<T>(T? t) where T : default { }
}

where T : default声明此处重写的是无class/struct约束的版本。

`unmanaged`约束

该约束可用于期望以直接操作内存块的方式读写类型实例的代码，如下所示。

unsafe public static byte[] ToByteArray<T>(this T argument) where T : unmanaged
{
    var size = sizeof(T);
    var result = new Byte[size];
    Byte* p = (byte*)&argument;
    for (var i = 0; i < size; i++)
        result[i] = *p++;
    return result;
}

由于对未知的类型T调用sizeof操作符，因此代码必须声明为不安全上下文(unsafe context)；若没有将类型参数T约束为unmanaged，sizeof操作符不可用。

委托约束

C#语言规范中未提供类似where T : delegate形式的约束，但可以用类型约束来实现类似的功能。
可以将T约束为System.Delegate/System.MulticastDelegate的子类，就可以在满足类型安全的前提下对委托进行操作。
代码演示如下所示。

// 操作委托的扩展方法
// 合并相同相同类型的委托
public static T? TypeSafeCombine<T>(this T source, T target) where T : Delegate
    => Delegate.Combine(source, target) as T;

// 定义两个相同类型的委托
Action first = () => Console.WriteLine("this");
Action second = () => Console.WriteLine("that");
// 合并&调用
var combined = first.TypeSafeCombine(second);   // √
combined!();

// 定义一个不同类型的委托
Func<bool> test = () => true;
// 如下的调用是错误的
var badCombined = first.TypeSafeCombine(test);  // ×

枚举约束

与委托调用类似，C#语言规范中并未直接提供纯粹的where T : enum约束(unmanaged约束允许传入枚举，但不是只允许枚举)，但可以用类型约束来实现类似功能。
可以将T约束为System.Enum的子类，就可以约束为仅允许枚举传入。
代码示例如下所示。

// 操作枚举的扩展方法
// 将给定枚举的值和名称构造成字典对象
public static Dictionary<int, string> EnumNamedValues<T>() where T : Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
    {
        result.Add(item, Enum.GetName(typeof(T), item)!);
    }
    return result;
}
// 定义枚举
enum SomeValue {A, B, C, D}
// 调用扩展方法并初始化字典
var dict = EnumNamedValues<SomeValue>();

类型参数继承/实现声明的类/接口(F-Bound)

本质是F-Bound，此处仅简要介绍官方文档对该约束的介绍及演示(样例中涉及到对C#支持接口静态成员的语言功能)，请参考下文(F-Bound)对该技巧的详细介绍。

// T必须实现接口本身
interface IAdditionSubtraction<T> where T : IAdditionSubtraction<T>
{
    // C#接口支持声明静态成员
    static abstract T operator +(T left, T right);
    static abstract T operator -(T left, T right);
}

`allows ref struct`约束

该约束是C#13.0新增的语言功能。

allows ref struct实际上是反约束，允许指定的类型参数可以是ref struct类型，因此该类型实例必须遵守如下规则：

不能被装箱
必须遵守引用安全规则(ref safety rules)
不能在禁止使用ref struct的地方使用该类型，例如static字段
实例可以使用scoped修饰符进行标记

F-Bound

F-Bound是一种泛型编程技巧，通常用于面向对象编程中，帮助在继承层次结构中实现类型自参的自引用。简单来说，是指通过继承某个类型的泛型类，子类可以返回类型自己。这个技巧在做流式接口设计、构建DSL或者处理复杂类型时非常有用。

F-Bound通常用于实现以下模式：基类定义了一个泛型方法，该方法返回该类（或者子类）的类型。而子类继承基类时，能够实现这个方法并返回自己的类型。

以下代码演示基本应用。

using System;

// 基类 Shape，使用 F-Bound 技巧
public abstract class Shape<T> where T : Shape<T>
{
    // 一个设置颜色的方法，返回当前类型（T）本身
    public T SetColor(string color)
    {
        Console.WriteLine($"Setting color to {color}");
        return (T)this;  // 返回当前类型本身
    }
    // 计算形状的面积（可以在子类中实现具体的面积计算）
    public abstract double GetArea();
}

// Circle 类，继承自 Shape<T>，并指定自己为 T
public class Circle : Shape<Circle>
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
    // 可以链式调用 SetColor 方法
    public Circle SetRadius(double radius)
    {
        Radius = radius;
        return this;
    }
}

// Rectangle 类，继承自 Shape<T>，并指定自己为 T
public class Rectangle : Shape<Rectangle>
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    public override double GetArea()
    {
        return Width * Height;
    }
    // 可以链式调用 SetColor 方法
    public Rectangle SetDimensions(double width, double height)
    {
        Width = width;
        Height = height;
        return this;
    }
}

// 测试 F-Bound
class Program
{
    static void Main(string[] args)
    {
        // 创建一个 Circle 对象，设置颜色和半径
        Circle circle = new Circle(5);
        circle.SetColor("Red")
              .SetRadius(10);
        Console.WriteLine($"Circle Area: {circle.GetArea()}");

        // 创建一个 Rectangle 对象，设置颜色和尺寸
        Rectangle rectangle = new Rectangle(4, 5);
        rectangle.SetColor("Blue")
                 .SetDimensions(6, 7);
        Console.WriteLine($"Rectangle Area: {rectangle.GetArea()}");
    }
}

可变性

可变性(variance)包含协变(covariance)、逆变(contravariance)和不变(invariance)。
语言层面的可变性支持是类型系统支持多态的关键部分，有的是由严格的语法支持，有的语言通过子类型兼容性简介体现。

简单来讲，协变(covariance)是指子类型可以赋值给父类型，常用于返回值(输出)场景；逆变(contravariance)是指父类型可以赋值给子类型，常用于参数(输入)场景；不变(invariance)是指完全相同的类型才能赋值，最安全也最严格。

可变性的核心概念(类型转换中派生类与基类之间的方向)在非泛型场景中也存在，但一般是隐式的，或称为“类型兼容性”问题。有些“类型兼容性”问题(例如数组协变)依赖编译器推断，但在运行时检查，可能抛出异常。常规场景中，参数逆变，返回值协变，便已是足够完善可靠的规则。

语言	协变(covariant)	逆变(contravariant)	说明
C#	✅ `out`	✅ `in`	泛型接口/委托支持，数组协变（但运行时检查）
Java	✅ `? extends`	✅ `? super`	使用通配符在泛型中表达变体，没有关键字（只能在使用处）
Scala	✅ `+T`	✅ `-T`	在泛型定义中支持变体标注，极其灵活
Python	✅（Typing 协变）	✅（Typing 逆变）	使用 `typing.Generic` + `covariant=True` 表达
Kotlin	✅ `out T`	✅ `in T`	类似 C#，在泛型类型定义中支持关键字
Swift	✅ 协变支持	✅（使用 protocol）	支持返回值协变、协议泛型逆变较间接
TypeScript	✅ 自动推导	✅ 自动推导	没有变体关键字，但函数/接口参数/返回值类型由结构类型系统自动推导
Rust	⚠️ 不支持协变/逆变关键字	⚠️ 不支持显式变体	有复杂的生命周期变体（‘a: ‘b）机制，不针对泛型类型参数

语言	泛型定义处变体	使用处变体	自动推导	安全检查	使用推荐度
C#	✅ `in`/`out`	✅ 委托	❌	✅ 编译时	✅✅✅
Java	❌	✅ `? extends` / `? super`	❌	✅ 编译时	✅✅
Scala	✅ `+T` / `-T`	✅	✅	✅	✅✅✅✅
Kotlin	✅ `out T` / `in T`	✅	✅	✅	✅✅✅
Swift	❌	部分支持	❌	✅	✅✅
TypeScript	❌	✅	✅✅✅	✅（结构化）	✅✅✅
Python	✅ (Typing)	✅	❌	✅（类型检查器）	✅✅
Rust	❌ 泛型不支持	❌	❌	✅（生命周期）	✅（不同维度）

上表整理自ChatGPT,其中Kotlin/Swift/TypeScript/Rust的相关内容尚未审慎求证。

C#

官方文档:\

Covariance and contravariance in generics

Covariance and Contravariance (C#) - Overview

Variance in Generic Interfaces (C#)

Creating Variant Generic Interfaces (C#)

Using Variance in Interfaces for Generic Collections (C#)

Variance in Delegates (C#)

Using Variance in Delegates (C#)

Using Variance for Func and Action Generic Delegates (C#)

泛型接口/委托中的可变性

泛型类、泛型方法中不能独立使用可变性修饰符in/out

// 定义泛型接口(实际是标准库中的类型，此处用以演示)
// 比较器接口(逆变)
public interface IEqualityComparer<in T>
{
    bool Equals(T? x, T? y);
    int GetHashCode([DisallowNull] T obj);
}
// 只读集合接口(协变)
public interface IReadOnlyList<out T> : IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
{
    T this[int index] { get; }
}

// 简单的继承关系
class Base { }
class Derived : Base { }

// 实现基类的比较器
class BaseComparer : IEqualityComparer<Base>
{
    public int GetHashCode(Base baseInstance)
    {
        return baseInstance.GetHashCode();
    }

    public bool Equals(Base? x, Base? y)
    {
        return x == y;
    }
}

// 基类的比较器可以作为派生类的比较器使用，此处体现了逆变
IEqualityComparer<BaseClass> baseComparer = new BaseComparer();
IEqualityComparer<DerivedClass> childComparer = baseComparer;

// 子类的集合可以作为基类的集合的使用，体现了协变
IReadOnlyList<Derived> childList = [];
IReadOnlyList<Base> baseList = childList;

// 泛型委托定义，参数逆变，返回值协变
public delegate TResult Func<in T, out TResult>(T arg);

// 两个委托实例
// 委托1：接受派生类，返回基类
Func<Derived, Base> func1 = (Derived d) =>
{
    Console.WriteLine(d);
    return new Base();
};
// 委托2：接受基类，返回派生类
Func<Base, Derived> func2 = (Base b) =>
{
    Console.WriteLine(b);
    return new Derived();
};

// 参数逆变：委托1期望接受派生类，实际可以接受基类
// 返回值协变：委托1期望返回基类，实际可以返回派生类
// 因此以下赋值是有效的(类型兼容)，委托2的实例可以作为委托1的实例调用
func1 += func2;

非泛型场景中的可变性

数组协变(强烈不推荐使用)

// 构造字符串数组实例，可以赋值给对象数组
object[] array = new string[] { "a", "b", "c" };
// 一般的读取不会有类型安全问题
var value = array[0];
// 赋值语句可以通过编译，但会在运行时抛出异常
array[0] = 1;

类型不安全。
该功能是编译器隐式支持的功能，但在运行时检查安全性。
协变的数组变量不存在严格的写保护，极有可能出现不经意的赋值操作，生产环境中应当避免使用。

方法重写返回值类

class A
{
    // 基类型中定义虚方法，返回值是基类型A
    public virtual A CreateInstance() { return new A(); }
}

class B : A
{
    // 派生类中重写方法，返回值类型是派生类型B，返回值协变
    public override B CreateInstance() { return new B(); }
}

类型安全。
该功能是编译器隐式支持的功能。
虚方法在子类中重写时，参数必须保持一致，但返回值可以是更具体的类型(返回值是协变的)，两个方法依然是“类型兼容”的。

非泛型委托的协变和逆变

// 定义基类型Animal及派生类型Dog
class Animal { }
class Dog : Animal { }

// 定义委托类型
delegate Animal Creator();
delegate void Handler(Dog dog);

// 定义普通方法
static Dog CreateDog() { return new Dog(); }
static void FeedAnimal(Animal animal) { }

// 方法可以构造为委托实例
Creator creator = CreateDog;    // 返回值协变
Handler handler = FeedAnimal;   // 参数逆变

类型安全。
该功能是编译器隐式支持的功能。
委托Creator期望生产Animal实例，实际上得到Dog实例，Dog作为Animal使用是类型安全的，因此Dog生产者作为Animal生产者也是类型安全的。这体现的是协变。
委托Handler期望消费Dog实例，因此调用Handler时给出的必定是Dog(或Dog派生类)实例，现在handler实际上是个消费Animal的实例，Dog作为Animal使用是类型安全的，消费Animal的方法消费Dog也是类型安全的，因此Animal消费者作为Dog消费者也是类型安全的。这体现的是逆变。
委托可以视为类型安全的函数类型，函数类型也可以视为构造类型(由参数类型+返回类型构造),在这个视角看待类型兼容也许有不一样的发现。可参考本站文章CTFP(category theory for programmer/面向程序员的范畴论)中协变和逆变的相关内容。

高阶泛型

Higher Kind

Higher Rank

参考链接

Generic programming

Parametric polymorphism

本文内容经过较长时间整理、

Java语言功能更新

Thu, 08 May 2025 00:00:00 +0800

Java语言功能更新

当前整理范围: JDK9->JDK21(LTS)

参考链接

A categorized list of all Java and JVM features since JDK 8 to 21 by Dávid Csákvári
New language features since Java 8 to 21 by Dávid Csákvári
Java 9 到 21 的语言特性更新 by Alex Tan - 本文是引文2中文翻译&整理
Java Language and Virtual Machine Specifications
Java Platform, Standard Edition Java Language Updates, Release 21 - Oracle官方整理的Java SE 9到特定版本的语言功能更新(修改URL中的版本号可以查看9到其他版本的功能更新)
JEP 0: JEP Index

参考以上内容进消化整理

Java 9

该版本新增的语言功能详情可参考: JEP 213: Milling Project Coin

1. 接口中允许私有方法

Java8允许接口实现默认方法，在Java9中允许接口实现私有方法。可以将期望复用但又不想公开暴露的代码放到私有方法中，由默认方法调用。

public interface Interface {
    default void op1() {
        // code ...
        common();
    }
    default void op2() {
        // code ...
        common();
    }
    private void common() {
        // common code
    }
}

2. 匿名内部类的钻石操作符

Java7引入钻石操作符<>，调用构造器时允许编译器推断泛型类型，降低没必要的类型参数声明，例如：List<Integer> numbers = new ArrayList<>();。但该功能并不支持匿名内部类，相关邮件: Diamond operator and anonymous classes。

相关问题已在Java9解决，此后以下代码可被接受了。

Callable<Integer> task = new Callable<>() {
    public Integer call() {
        return doSomething();
    }
};

Comparator<MyClass> FORWARD = new Comparator<>() {
    @Override
    public int compare(MyClass first, MyClass second) {
        // comparator logic
    }
};

3. effectively-final变量在`try-with-resources`语句中可作为资源使用

Java7引入try-with-resources语句来简化资源释放，示例如下。

// java7之前需要手动管理资源释放
BufferedReader br = new BufferedReader(...);
try {
    return br.readLine();
} finally {
    if (br != null) {
        br.close();
    }
}

// java7可以用该语句自动释放资源，减少样板代码
try (BufferedReader br = new BufferedReader(...)) {
    return br.readLine();
}

实际使用中，也会存在一些短板，示例如下。

// 多个资源的时候代码有点难读
try (BufferedReader br1 = new BufferedReader(...);
    BufferedReader br2 = new BufferedReader(...)) {
    System.out.println(br1.readLine() + br2.readLine());
}

// 处理已有资源的时候仍需要定义变量
try (Closeable c = resouce) {
    // ...
}

Java9解决了这些问题，现在也可以处理不可变或实际不可变的局部变量，示例如下。

BufferedReader br1 = new BufferedReader(...);
BufferedReader br2 = new BufferedReader(...);
try (br1; br2) {
    System.out.println(br1.readLine() + br2.readLine());
}

注意，由于变量在try-with-resources语句外可用，但此时资源已被释放，所以操作基本都会失败，要特别注意。示例如下。
1
2
3
4
5
BufferedReader br = new BufferedReader(...);
try (br) {
    System.out.println(br.readLine());
}
br.readLine(); // Boom!

4. 下划线不可作为标识符使用

Java8中将_作为标识符使用时，编译器会输出警告。Java9更进一步，将此情形视为错误，这是保留该符号未来做特殊使用。

// java7-: 变量可用
// java8: 编译警告 变量可用
// java9 -> 20: 编译错误
// java21(开启预览功能): 编译通过 变量不可用
// java22+: 编译通过 变量不可用
int _ = 10;

5. 警告改进

@SafeVarargs注解只能用于不可被覆写的方法，此前只包括构造方法、静态方法、final实例方法。实际上私有实例方法也算是，现在可以将@SafeVarargs注解在私有方法上用以抑制Type safety: Potential heap pollution via varargs parameter警告。可变参数和泛型两者结合使用时可能产生问题，编译器会输出警告，当程序员确保没有进行危险操作时，使用该注解抑制警告。注解使用示例如下(参考自Annotation Type SafeVarargs)。

// 此前只能用于标记构造函数、static方法、final方法

@SafeVarargs // 实际上并不安全
static void m(List<String>... stringLists) {
    Object[] array = stringLists;
    List<Integer> tmpList = Arrays.asList(42);
    array[0] = tmpList; // 该赋值实际上不合法、但编译会正常通过
    String s = stringLists[0].get(0); // 运行时抛出ClassCastException
}

此外编译器不再为引入废弃类型告警，这些警告已经在调用的地方展示了。参考JEP 211: Elide Deprecation Warnings on Import Statements

Java 11 (LTS)

局部变量类型推断

Java 10(JEP 286: Local-Variable Type Inference)中引入(Lambda中尚不支持)，Java 11(JEP 323: Local-Variable Syntax for Lambda Parameters)中得到改进

该功能允许声明局部变量时可以略去显式类型声明，变量类型由编译器推断，某些场景中可以使代码精炼易读。如下所示。

`1`	`var awesome = new MyAwesomeClass();`

注意：与动态类型无关。

但也有些场景，使用显式类型声明更具优势，以下通过几个例子讨论。

在源码中移除显式的类型信息，可能会影响可读性。IDE能起到一定帮助，但是在代码评审或快速浏览代码时就会有影响。例如在工厂模式或构造者模式中，就要找到负责构建对象的代码，才能推断出其类型。参考以下示例。

1
2
3

var date = LocalDate.parse("2019-08-13");   // LocalDate 
var dayOfWeek = date.getDayOfWeek();        // java.time.DayOfWeek
var dayOfMonth = date.getDayOfMonth();      // int

对以上示例，若使用Joda库，调用date.getDayOfWeek()时返回值为整型，同样的方法名在不同的库中返回值也不一定相同。当代码较长时，翻看上下文确定类型变得更加困难，因此使用var要时刻考虑代码可读性。

时刻考虑可读性

此外，var消除所有可用的类型信息，甚至导致无法被推断。绝大多数情形中编译器能捕获问题，例如var不能针对lambda和方法引用进行推断，因为编译器依赖于表达式左边的声明来确定类型。但也存在一些例外。

比如当和钻石操作符搭配使用时。例如var map = new HashMap<>();，语法上是可行的，编译器甚至不会报出警告。然而完全不指定泛型类型，类型推断会给出Map<Object, Object>的结果，这大概率并非预期。此时可以考虑常规语法Map<String, String> map = new HashMap<>();，或者替换掉类型操作符var map = new HashMap<String, String>();。

与基础类型使用时也会有问题，例如byte b = 1/short s = 1/int i = 1/long l = 1/floate f = 1/double d = 1，没有显式类型声明时，类型会被推断为int。处理基本类型时，要么使用类型字面量(例如1L/1.0F/1.0D)，要么完全不使用var。

保留重要的类型信息

参考官方针对var的代码风格指南(Local Variable Type Inference Style Guidelines)和常见问题(Local Variable Type Inference Frequently Asked Questions)。

使用中尽量以保守的态度引入代码，在局部变量中使用，使之尽量在较小的作用域中生效。

仍需强调，var并非是个新的关键字，而是个保留类名。当它用作类型名的时候是有特殊含义的，其他场景下依然是个合法的标识符。例如var var = 10是个合法的声明。

目前尚不存在特定的关键字来声明不可变(例如val或const)，目前可以用final var达成预期。

参考官方的代码风格指南

Java 14

`switch`表达式

可用: 14-JEP 361: Switch Expressions (预览: 12-JEP 325: Switch Expressions (Preview); 13-JEP 354: Switch Expressions (Second Preview))

switch不再只是语句，可以是表达式，但要注意两者语法略有区别。

语句示例如下，官方文档请参考The switch Statement

// switch语句语法，逻辑上是if-else-if的简化。
// 接受的数据类型如下:
//  1. 基本数据类型: byte short int char
//  2. 包装数据类型: Byte Short Integer Character
//  3. 字符串(Java SE 7开始支持)
//  4. 枚举类型(Java SE 7开始支持)
// 注意：
//  1. 缺少break会导致的击穿(fall-through，即代码连续执行)；
//  2. null会导致抛出空指针异常
//  3. 所有case共享一个作用域(临时变量不允许重复定义)
switch (expr) {
    case value1:
        // code
        break;
    case value2:
    case value3:
        // code
        break;
    default:
        // code
}

表达式示例如下，可用于任何接受表达式的地方，例如函数参数。

int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    default -> {
        String s = day.toString();
        int result = s.length();
        yield result;
    }
};

表达式不存在击穿，可以为case指定多个常量，逗号分隔。
分支可以是单个表达式，也可是语句块中的多条语句(必须以yield value;语句返回该语句块的求值结果)。
分支是独立作用域，因此可以随意定义同名变量。
表达式必须覆盖所有条件，对于常规的字符串、基本类型及其包装类型等，必须提供default分支；对于枚举，要么显式声明所有情况，要么提供default，前者是最佳实践，当枚举值变更时，编译阶段即可发现错误。

推荐使用表达式而不是语句

此处同时记录类似语句的冒号语法，但强烈不建议使用！
1
2
3
4
5
6
7
int result = switch (s) {
    case "foo":
    case "bar":
        yield 2;
    default:
        yield 3;
};
这种形式也能作为表达式使用，但击穿和共享作用域也出现了。强烈不推荐，使用箭头形式的表达式即可，避免所有问题。

Java 15

1. 文本块

可用: 15-JEP 378: Text Blocks (预览: 13-JEP 355: Text Blocks (Preview); 14-JEP 368: Text Blocks (Second Preview))

String html = """
          <html>
            <body>
              <p>Hello, world</p>
            </body>
          </html>
          """;

System.out.println(html);

该功能简化多行文本初始化工作。文本块与字符串字面量相似，但换行和引号都不需要转义。

文本块以"""开始，后面紧跟换行；以"""结束，可以紧跟最后一行，也可以单独一行。源代码中每个换行的地方都会产生一个\n字符。

文本段可以和相邻的Java代码对齐，编译器会检查每行用于缩进的空格，找到缩进最少的行，然后将每行都转化为这个相同的最少缩进。若结尾的"""是在一个单独的行，注意它的缩进情况，有可能会整体的缩进发生改变。开头的"""不会影响缩进移除，所以文本块没有必要和其对齐。

String类提供了编程方式处理缩进的方法，indent方法接受一个整数参数，返回新的符合特定缩进级别的字符串；stripIndent方法返回移除所有缩进的字符串。

此外，使用文本块需要注意以下事项：

尚不支持插值，当前可以用String::formatted及String::format来实现。
行尾空格通常会被忽略掉，当需要行尾空格时，要在行尾添加\s或\t。
换行使用\n，与当前操作系统或源代码采用的换行符无关，若存在兼容性问题，可以用String::replace进行替换。
源代码可以采用任意类型的缩进：制表符、空格或者两者混用，但文本块的每行必须使用一致的缩进。

2. 携带详细信息的空指针异常

可用: 15-Enable ShowCodeDetailsInExceptionMessages by default (14-JEP 358: Helpful NullPointerExceptions 启动程序时需指定-XX:+ShowCodeDetailsInExceptionMessages参数)

node.getElementsByTagName("name").item(0).getChildNodes().item(0).getNodeValue();

// 以前的异常信息
Exception in thread "main" java.lang.NullPointerException
        at Unlucky.method(Unlucky.java:83)

// 现在的异常信息，包含不能被执行的步骤，及其失败原因
Exception in thread "main" java.lang.NullPointerException:
  Cannot invoke "org.w3c.dom.Node.getChildNodes()" because the return value of "org.w3c.dom.NodeList.item(int)" is null
        at Unlucky.method(Unlucky.java:83)

空指针异常扩展是在JVM层面实现的，即使代码编译为较老的Java版本或者其他的JVM语言(例如Scala或Kotlin)也同样能受益。

但并非所有的空指针异常都能得到这些额外的信息，仅仅是被JVM创建并抛出的才行：

对null读写字段
对null调用方法
对null数据读写元素(索引信息不会输出)
对null拆箱

此外，该功能不支持序列化。例如通过RMI方式远程调用代码发生异常时，异常信息里不会包含相关信息。

Java 16

1. 记录类

可用: 16-JEP 395: Records (预览: 14-JEP 359: Records (Preview); 15-JEP 397: Sealed Classes (Second Preview))

其它相关内容: Data Classes and Sealed Types for Java; Records Come to Java

记录类给Java带来了数据类和封闭类型(Data Classes and Sealed Types for Java)，用于携带不可变数据。记录类可以视为元组(tuple)。

`1`	`public record Point(int x, int y) {}`

以上简练的语法声明了一个记录类Point，其具备以下定义

两个private final字段int x和int y
一个接受x和y作为参数的构造器
字段getter方法x()和y()
纳入字段x和y的方法hashCode、equals和toString

使用方式与普通类一致。

1
2
3

var point = new Point(1, 2);
point.x(); // returns 1
point.y(); // returns 2

记录类设计为浅层不可变数据(shallowly immutable data)的透明载体(transparent carriers)，定义和使用都存在限制。

记录类的字段默认final，实际上不允许非final字段。
定义记录时必须提供所有字段，记录体内不允许定义额外字段。
允许定义额外的构造方法来提供默认值，但无法隐藏包含所有字段的标准构造方法(canonical constructor)。
不能继承其它类，是隐式final的，不能被继承。
不能是抽象的。
不能声明native方法。

记录类强调不可变性，字段赋值只能通过构造方法。编译器自动添加的隐式标准构造方法和类具有一致的可见性，显式声明标准构造方法时其可见性不低于类本身。可以自定义构造方法，可以是任意可见性，但其实现必须最终委派给标准构造方法完成初始化。

对于其中的每个字段，会自动生成其getter，名称与字段名一致。可以显式定义甚至重写。

记录类可以拥有静态方法和实例方法。

代码示例如下。

record Point(int x, int y) {
    // 显式声明标准构造方法，对数据进行验证，只能保持或放大可见性
    public Point {
        if (x < 0) {
            throw new IllegalArgumentException("x >= 0");
        }
        if (y < 0) {
            // 只能在标准构造方法中进行赋值操作
            y = 0;
        }
    }
    // 声明额外构造方法，委派给标准构造方法，可以限制可见性
    Point(int i) {
        this(i, i);
    }
    // 声明额外构造方法，委派给其它构造方法，最终由标准构造方法完成初始化，可以限制可见性
    private Point() {
        this(0);
    }
    // 显式定义或重写默认为x提供的getter，同样可以处理hashCode equals toString
    @Override
    public int x() {
        // code...
        return x;
    }
    // 支持静态方法
    static Point zero() {
        // 调用了私有构造方法
        return new Point();
    }
    // 支持实例方法
    boolean isZero() {
        return x == 0 && y == 0;
    }
}

记录类专注于承载数据，因此定制性略有受限。但也是得益于这样的设计，序列化也十分容易且安全(相比于常规的类)。

记录类的实例能被序列化和反序列化。然而不能通过提供writeObject readObject readObjectNoData writeExternal或 readExternal方法来自定义其处理流程。记录类的组件（字段）负责序列化，而记录类的标准构造方法掌管反序列化。

序列化正好基于成员变量的状态，反序列化又总会调用标准构造方法，所以不可能创建一个无效状态的记录类。从开发者角度看，序列化和反序列化与以往一样。

public record Point(int x, int y) implements Serializable { }

public static void recordSerializationExample() throws Exception {
    Point point = new Point(1, 2);

    // 序列化
    ObjectOutputStream oos =
        new ObjectOutputStream(new FileOutputStream("tmp"));
    oos.writeObject(point);

    // 反序列化
    ObjectInputStream ois =
        new ObjectInputStream(new FileInputStream("tmp"));
    Point deserialized = (Point) ois.readObject();
}

关于记录类，推荐注意以下实践。

使用本地记录类来构建中间转化变量

复杂的数据转换需要中间变量，Java 16之前的典型方案是依赖于Pair或三方库里相似的holder类，再或者是自己定义（可能是静态内部）类来承载数据。前者通常不够灵活，后者又在仅用于单个方法的上下文中引入了其它类，污染了命名空间。虽然也可以在方法体中定义类，但也因为其啰嗦的语法很少这么用。

Java 16进行了改进，可以在方法体中定义本地记录类。

public List<Product> findProductsWithMostSaving(List<Product> products) {
    record ProductWithSaving(Product product, double savingInEur) {}

    products.stream()
        .map(p -> new ProductWithSaving(p, p.basePriceInEur * p.discountPercentage))
        .sorted((p1, p2) -> Double.compare(p2.savingInEur, p1.savingInEur))
        .map(ProductWithSaving::product)
        .limit(5)
        .collect(Collectors.toList());
}

记录类紧凑的语法正好契合 Steam API 紧凑的语法。

除了记录类外，这个改进也适用于本地枚举甚至接口。

检查引用的类库

记录类没有遵循JavaBeans的约定，一些遵循约定的工具类和记录类可能不能正常使用。

没有默认的构造方法
没有setter方法
访问器方法不依照getX()格式

例如，记录类不能用作JPA(例如Hibernate)的实体。有一些关于JPA遵循记录类规范的讨论，但迄今为止没找到相关开发进度的报道。但也有文章指出将记录类能应用到项目中且没有问题。

大多数Dávid Csákvári 试过的工具类（包括Jackson，Apache Commons Lang，JSON-P，Guava ）都支持记录类，但还存在些小问题。比如，流行的JSON库Jackson较早就支持记录类。它的大多数特性，包括对记录类和 JavaBeans 的序列化、反序列化都没什么问题，但操控对象的特性还没适配。

Spring也在许多情况下对记录类提供开箱即用的支持，包括序列化甚至依赖注入，但许多 Spring 应用程序使用的ModelMapper库不支持将JavaBeans映射到记录类。

建议在使用记录类前先升级并检查使用的工具库，避免意外之喜，但大体上来说，可以认为流行的工具库已经涵盖了大部分特性。

参看关于记录类的工具库集成试验。

使用模式匹配快速访问字段

实践中建议考虑使用switch模式匹配及instanceof模式匹配与记录类结合使用，便捷地解构对象。

2. `instanceof`模式匹配

可用: 16-JEP 394: Pattern Matching for instanceof (预览: 14-JEP 305: Pattern Matching for instanceof (Preview); 15-JEP 375: Pattern Matching for instanceof (Second Preview))

// 传统形式代码，需要进行显式类型转换
if (obj instanceof String) {
    String s = (String) obj;
    // code
}

// 现在更简练
if (obj instanceof String s) {
    // code
}

该模式是类型检查(obj instanceof String)和模式变量(s)的组合，类型检查和旧的instanceof操作符几乎一样，但模式确定无法匹配的话会导致编译错误。示例如下。

// 该模式匹配必定失败，因此在编译时报错
Integer i = 1;
if (i instanceof String s) { 
    // code
}

仅在检查通过时，模式变量才会从目标变量中提取出来。几乎和常规的非final变量一样，值能被修改、会隐藏(shadow)字段、同名变量引发编译错误。但模式变量作用域是基于控制流分析确定的，仅限在**明确匹配(definitely matched)**的作用域内生效，甚至支持更复杂的情形。

// 可以用于后续判断
if (obj instanceof String s && s.length() > 5) {
    // code...
}

// 也支持提前返回值或抛出异常
private static int getLength(Object obj) {
    if (!(obj instanceof String s)) {
        throw new IllegalArgumentException();
    }
    // 代码是正确的，此处是模式变量的作用域
    return s.length();
}

流程控制的作用域解析和现有的流程解析很相似，比如对明确赋值(definite assignment)的检查，代码示例如下。

private static int getDoubleLength(String s) {
    int a; // 声明但未赋值
    if (s == null) {
        return 0; // 已返回
    } else {
        a = s.length(); // 赋值
    }
    // 已确定完成赋值 因此直接可用
    a = a * 2;
    return a;
}

相对于其它现代编程语言还是稍显啰嗦，例如kotlin无需声明模式变量，直接在原变量上调用方法。但实际上模式变量是确保向后兼容性的手段。改变obj instanceof String 中的类型也就意味着，在其被用作重载方法参数的时候，调用可能会被解析成这个方法的不同版本。

1
2
3

if (obj is String) {
    print(obj.length)
}

在该版本中预览了记录类和模式匹配组合使用的“记录类模式”，该模式匹配将在下文详细介绍。

Java 17 (LTS)

封闭类

可用: 17-JEP 409: Sealed Classes (预览: 15-JEP 360: Sealed Classes (Preview); 16-JEP 397: Sealed Classes (Second Preview))

封闭类用于限定哪些类或接口可以被用于继承或实现它们。之前的机制是final结合访问修饰符，标记为final的类不允许被继承，配合访问修饰符就能确保仅同一包中的类才能继承。封闭类提供更细粒度的控制，让开发者能显式地列举其子类。

// sealed声明封闭类，permits声明允许直接继承该封闭类的类型(实际上permits是要求必须直接继承封闭类)
public sealed class Shape
    permits Circle, Quadrilateral, WeirdShape {}

// final声明该类不允许再被继承
public final class Circle extends Shape {}

public sealed class Quadrilateral extends Shape
    permits Rectangle, Parallelogram {}
public final class Rectangle extends Quadrilateral {}
public final class Parallelogram extends Quadrilateral {}

// non-sealed声明该类可以被任意继承
public non-sealed class WeirdShape extends Shape {}

继承封闭类时，必须通过添加final/sealed/non-sealed显式定义出封闭类的边界，这也就使整条继承链的继承情况是明确定义的。

被允许继承的类必须和父类（封闭类）在同一个包里，如果是使用java模块，那它们必须在同一模块中。

如果类都比较简短，且大部分和数据相关，可以声明在同一个源文件，permits关键字可以忽略。

public sealed class Shape {
    public final class Circle extends Shape {}

    public sealed class Quadrilateral extends Shape {
        public final class Rectangle extends Quadrilateral {}
        public final class Parallelogram extends Quadrilateral {}
    }

    public non-sealed class WeirdShape extends Shape {}
}

记录类是隐式final的，可以作为封闭类的子类。

推荐使用封闭类而非枚举

，比如： java

enum Expression { ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION }

在封闭类出现前，只能用枚举类对固定可选项建模。然而所有的情况都要在同一个源文件中写完，且枚举类仅支持常量，不支持需要实例的情况，例如表示一个类型的单个消息。

封闭类提供一个比枚举类更好的选择，使得用普通类来为固定可选项建模成为可能。配合switch模式匹配就更能充分发挥其作用，封闭类能像枚举一样在switch表达式中使用，编译器能自动检查代码是否涵盖了全部情况。

枚举类的值可以使用values方法列举出来。对应到封闭类和封闭接口，可以使用getPermittedSubclasses方法例举出所有被允许继承的子类。

Java 21 (LTS)

1. `switch`模式匹配

可用: 21-JEP 441: Pattern Matching for switch; 预览: 17-JEP 406: Pattern Matching for switch (Preview); 18-JEP 420: Pattern Matching for switch (Second Preview); 19-JEP 427: Pattern Matching for switch (Third Preview); 20-JEP 433: Pattern Matching for switch (Fourth Preview)

switch表达式可以对任意类型进行复杂的模式匹配，以下通过示例演示。

switch支持常量模式匹配，与传统的表达式用法基本一致

// 对枚举值进行匹配
var symbol = switch (expr) {
    case ADDITION       -> "+";
    case SUBTRACTION    -> "-";
    case MULTIPLICATION -> "*";
    case DIVISION       -> "/";
};

switch支持类型模式匹配，类似instanceof模式匹配

return switch (expression) {
    case Addition expr       -> "+";
    case Subtraction expr    -> "-";
    case Multiplication expr -> "*";
    case Division expr       -> "/";
};

模式还支持卫语句(guard)，写法为type pattern when guard expression

String formatted = switch (o) {
    case Integer i when i > 10 -> String.format("a large Integer %d", i);
    case Integer i             -> String.format("a small Integer %d", i);
    default                    -> "something else";
};

这与instanceof模式匹配是一致的，代码如下所示。

if (o instanceof Integer i && i > 10) {
    return String.format("a large Integer %d", i);
} else if (o instanceof Integer i) {
    return String.format("a large Integer %d", i);
} else {
    return "something else";
}

模式变量作用域也类似，是分支敏感的。例如在case Integer i && i > 10 -> String.format("a large Integer %d", i);语句中，变量i作用域是卫语句及其右侧的表达式。

switch支持匹配null值。传统的switch语句接受到null时会抛出空指针异常，switch表达式为保持后向兼容性，当没有显式声明null模式时也会抛出异常。

switch (s) {
    case null  -> System.out.println("Null");
    case "Foo" -> System.out.println("Foo");
    default    -> System.out.println("Something else");
}

switch表达式必须是详尽的，要求覆盖所有可能输入。该约束与枚举、封闭类和泛型能很好协作。若只有一组固定输入，那便可以略去默认分支。这对维护代码有很大帮助，例如当给枚举新增常量，那么涉及该枚举的所有缺失默认分支的匹配都会在编译时抛出错误。详尽性检查是在编译时进行，但如果在运行时有新的实现（例如来自单独的编译），编译器还会插入一个默认分支去抛出MatchException。

sealed interface I<T> permits A, B {}
final class A<X> implements I<String> {}
final class B<Y> implements I<Y> {}

static int testGenericSealedExhaustive(I<Integer> i) {
    return switch (i) {
        case B<Integer> bi -> 42;
    };
}

以上代码来自JEP 441: Pattern Matching for switch，展示了模式匹配与封闭类和泛型的写作，代码能正确通过编译是因为编译器可以检测到只有A和B是I的有效子类型，并且由于泛性参数Integer，该参数只能是B<Integer>的实例。

编译器也会执行与详尽性检查相反的操作，当编译器发现一个分支完全涵盖另一个分支时，会报出编译错误。代码示例如下。

Object o = 1234;
// 编译错误，第二个条件已包含在第一个条件分支中
String formatted = switch (o) {
    case Integer i             -> String.format("a small Integer %d", i);
    case Integer i when i > 10 -> String.format("a large Integer %d", i);
    default                    -> "something else";
};

出于代码可读性及正确性原因，强烈建议将常量匹配放在其相应的类型匹配之前，使更具体的分支先被匹配到。考虑以下代码，如果将常量匹配与带卫语句的类型匹配交换次序，当传入1时，会得到不同的结果。

switch(num) {
    case -1, 1 -> "special case";
    case Integer i when i > 0 -> "positive number";
    case Integer i -> "other integer";
}

原文说的是编译器强制要求常量置前，实测并非如此。

2. 记录类模式

可用: 21-JEP 440: Record Patterns (预览: 19-JEP 405: Record Patterns (Preview); 20-JEP 432: Record Patterns (Second Preview))

记录类模式可以看作更强大的类型模式，在匹配时可以直接解构出对象的值(支持嵌套)。

interface Point { }
record Point2D(int x, int y) implements Point { }
record Point3D(int x, int y, int z) implements Point { }

enum Color { RED, GREEN, BLUE }
record ColoredPoint(Point p, Color c) { }

// 构造对象
Point p1 = new ColoredPoint(new Point2D(3, 4), Color.GREEN);
Point p2 = new ColoredPoint(new Point2D(1, 2, 3), Color.RED);

// switch模式匹配解构对象
var length = switch (p) {
    case ColoredPoint(Point3D(int x, int y, int z), Color c) -> Math.sqrt(x*x + y*y + z*z);
    case ColoredPoint(Point2D(int x, int y), Color c) -> Math.sqrt(x*x + y*y);
    case ColoredPoint(Point p, Color c) -> 0;
}

// instanceof模式匹配也可以直接解构，实践中按需选择即可
if (p instanceof ColoredPoint(Point2D(int x, int y), Color c)) {
    // code
} else if (p instanceof ColoredPoint(Point3D(int x, int y, int z), Color c)) {
    // code
}

记录类模式简化了复杂的对象类型验证及字段提取工作，尤其是有嵌套对象的场景。

3. 其它预览功能

JDK21中还有如下的预览语言功能，此处仅记录。待到下个LTS版本发布(Java 25 2025-09)再做详细整理。

匿名模式和匿名变量 JEP 443: Unnamed Patterns and Variables (Preview)
字符串模板 JEP 430: String Templates (Preview)
未具名类和实例主方法 JEP 445: Unnamed Classes and Instance Main Methods (Preview)

近期终于能稍微抽身，做些“新潮”的东西，动手时与时代的脱节感愈发强烈，甚至感觉无从下手。翻看Git仓库，上次正经整理博客是2020年，已经是五年前的事情了。这五年感觉像是遗失的梦一般，倏忽跳跃到现在，向前回忆却想不到闪光之处。懈怠多年，轻易挥霍时光，对自己感到遗憾和抱歉。学习应当是终生坚持的事情，无论是编程还是其他。重新出发，充实自己，永不止步。

Scala Style

Thu, 16 Jul 2020 00:00:00 +0800

Scala Style

参照官方文档推荐的Scala代码风格SCALA STYLE GUIDE

缩进和换行

该部分参考INDENTATION

每个缩进级别都是2个空格

尽量保证每行不要超过80字符，若有表达式超出了，尽量考虑换行

// 缩进是2个空格
object Foo {
  def bar(): Unit = {
    val x = 10
    //...
  }
}

// ---

// 超长表达式的换行
val result = 1 + 2 + 3 + 4 + 5 + 6 +
  7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 +
  15 + 16 + 17 + 18 + 19 + 20

// 超多参数的函数调用，变量名超长时要注意方法在新一行开始调用
val myLongFieldNameWithNoRealPoint =
  foo(
    someVeryLongFieldName,
    andAnotherVeryLongFieldName,
    "this is a string",
    3.1415)

命名约定

该部分内容参考NAMING CONVENTIONS

绝大多数情况下，Scala采用小驼峰风格lowerCamelCase，一些缩写术语也作为普通单词对待xHtml/maxId，由于下划线在Scala语法中有特殊意义，因此非常不推荐使用（若要强行使用、编译器也不会主动拒绝此类代码）

类、特质

类和特质的命名应当遵循大驼峰风格，跟Java中对于类的命名约定是一致的

有时类或特质以及它们的成员是用于描述格式、文档或者某些协议，此时为了保持与输出一模一样，可以不遵循对类名和成员的命名约定。但应注意只能在这种特定用途使用，不能影响其余代码

对象

对象一般也遵循大驼峰命名风格，但是当之功能上模仿包或者函数的时候，可以不遵循这一约定

// 功能类似一个名为`ast`的包
object ast {
  sealed trait Expr

  case class Plus(e1: Expr, e2: Expr) extends Expr
  ...
}

// 功能类似一个名为`inc`的函数
object inc {
  def apply(x: Int): Int = x + 1
}

包

对包的命名应当遵循Java的命名约定，例如com.foo.bar

有时会出现必须用_root_指定包的全名的情况。但应注意不要过度使用_root_，以相对包路径方式来引用嵌套包是很推荐的做法，此外这十分有助于简化import语句

方法

Scala中，对于普通文本/字母名称的方法应当采用小驼峰风格

Accessors/Mutators 属性访问器、修改器

其功能可以直接对应成Java中常用的getter/setter，但是命名风格与Java完全不一致，Scala中采用一下约定

对于属性的访问器/Accessors，该方法的名称与属性名称保持完全一致

某些情况下，对于Boolean类型的访问器，允许在前面加上is（例如isEmpty），这种情况下也要保证没有相应的修改器才行。（Lift框架中，对此种情况的约定是在属性名后加_?，这是非标做法，注意不要滥用该做法）

对于修改器/Mutators，其方法名应当是在属性名后加_=。遵循该约定后，调用点对属性的赋值将映射为调用该修改器方法（这不再仅是个约定，而变成了语言的约束）

class Foo {
  def bar = ...
  def bar_=(bar: Bar) {
    ...
  }
  def isBaz = ...
}

val foo = new Foo
foo.bar             // accessor
foo.bar = bar2      // mutator
foo.isBaz           // boolean property

由于Java没有对于属性及其绑定的一等支持，因此有了getter/setter范式的存在。在Scala中，有专门的库用于做此类支持

1
2
3

class Company {
  val string: Property[String] = Property("Initial Value") // 一个不变的属性对象引用，但属性对象保存的值是可以修改的
}

无参方法/函数的括号

定义和调用无参方法/函数时，应当注意并考虑清楚是否要带括号

1
2

def foo1() = ...
def foo2 = ...

以上两个方法在Scala中都是合法的，两者也是不同的。其中foo2只能无括号方式调用、但foo1可以带括号调用。

实际行为类似访问器的方法、而且方法调用无任何副作用，那么声明时不应当带括号。若有副作用，那么就应当带上括号。调用时也应当遵循此约定，若是要调用含副作用的方法，注意带上其括号

符号方法名

尽量避免！

Scala语言库中符号用得很多，但实际编程中对于符号的使用还是应当慎重考虑，尤其是这一符号没有其标准意义时。两个合理的使用场景是：DSL中(actor ! msg)；数学操作符（a + b c :: d）。在标准的API设计领域，严格限制符号方法名只能使用在纯函数式操作中。可以定义>>=来进行单子的bind操作，但是不允许定义<<方法向输出流写东西。因为前者是有完备数学定义的，而且没有任何副作用，但后者既没有标准定义也不是无副作用的操作。

一般而言，能以符号命名的方法应当是广为人知或者能很好地自描述的。一旦需要解释这个方法到底在做什么，那么该方法就不适合用符号名称了。

常量、值、变量和方法

常量命名应采用大驼峰风格，例如scala.math.Pi；一般的值、变量和方法应采用小驼峰命名风格

类型参数（泛型）

简单的类型参数一般用一个大写字母即可，一般从A开始

1
2
3

class List[A] {
  def map[B](f: A => B): List[B] = ...
}

若是类型参数有特定意义，那么可以用具备描述性的单词，该单词遵循类型的命名规则（注意不是全大写）；当然，若是的类型参数的作用域足够小，直接用单个字母依然没有问题

// 可以用单词
class Map[Key, Value] {
  def get(key: Key): Value
  def put(key: Key, value: Value): Unit
}

// 也可以用字母
class Map[K, V] {
  def get(key: K): V
  def put(key: K, value: V): Unit
}

HKT

理论上讲，高阶类型参数跟一般类型参数没什么不同（当然高阶kind至少是* => *而不是简单的*）。一般而言，更倾向于使用更具描述性的单词，而不是一个简单的字母，例如class HigherOrderMap[Key[_], Value[_]] { ... }。对于一些基础概念，可以用简单的字母，例如F[_]来表述函子、M[_]表述单子。

注解

Scala中注解一般采用小驼峰

特别说明

由于Scala本质上是函数式编程语言，因此def add(a: Int, b: Int) = a + b这种名称短小、方法体简单的函数定义很常见。这种行为在Java中是个很不好的做法，但是在Scala中是很推荐的。

类型

该部分内容参考TYPES

类型推断

在保证代码清晰的前提下，尽可能地用上类型推断的功能。在向外开放API的地方，注意显式给出类型信息。

对于私有字段或本地变量，几乎完全不用显式给出类型，因为它们的类型我们一般能直接从值上看出来，对于那些不那么明显的、或者比较复杂的，还是应该显式给出类型。对于所有的公共成员，必须明确给出类型信息。

特别地，Scala编译器对于函数值/λ表达式的类型推断做了特殊处理，对于需要传入函数的高阶函数调用，可以不必声明该表达式参数的类型。考虑ints.map(i => i * 2)，编译器可以直接推断出λ表达式的参数i的类型。

类型注解

类型注解该以如下方式写value: Type，例如i: Int、d: Double甚至l: ::

Type ascription / 类型归属？

类型归属的语法跟类型注解是一致的，所以很容易搞混，例如Nil: List[String] None: Option[String] "Str12": AnyRef Set(values: _*)。类型归属是在向编译器声明我们期望该值的类型是什么，一般在做上转型操作，前三者例子便是如此；但Scala中更常见的可能是最后一例，当调用一个可变参数的方法时、期望将序列展开，因此用到_*（否则会变成可变参数列表仅接收到一个参数，该参数是个序列）

函数

函数的类型遵循(argType1, argType2, ...) => retType的写法。特别地，对于元数为1的函数，可以省去参数的括号，写作argType => retType

结构类型

若是结构类型的总长度小于50字符，那么应该写在一行里，否则就应写作多行，并且为之分配一个类型别名。

// 简单结构类型
def foo(a: { val bar: String }) = ...

// 复杂结构类型
private type FooParam = {
  val baz: List[String => String]
  def bar(a: Int, b: Int): String
}

def foo(a: FooParam) = ...

当把简单结构类型写在一行的时候，多个成员之间应该用一个分号和空格隔开，成员跟花括号之间也应有空格

结构类型是在运行时用反射实现的，因此性能较差。开发时还是应尽可能选择常规类型，除非结构类型能带来明显的益处

嵌套代码块

NESTED BLOCKS

代码块

左花括号必须跟它所归属定义的声明放在同一行

括号

当某表达式跨越多行且需要小括号包裹时，左右两小括号与其包裹的内容之间应当没有空格、并且与内容保持同一行；

1
2

(this + is a very ++ long *
  expression)

小括号也可用于禁用分号推断，因此允许更喜欢将操作符写在开头的开发者写出如下代码

(  someCondition
|| someOtherCondition
|| thirdCondition
)

声明

DECLARATIONS

类

类、对象、特质的构造器应当尽可能放在一整行里，当这一行过长（比如超出100字符）的时候，那么需要将该行拆成多行，每个构造器参数及其跟随的逗号占一行，如下所示

// 单行形式
class Person(name: String, age: Int) {
  …
}

// 多行形式
class Person(
  name: String,
  age: Int,
  birthdate: Date,
  astrologicalSign: String,
  shoeSize: Int,
  favoriteColor: java.awt.Color,
) {
  def firstMethod: Foo = …
}

若是该类、对象、特质扩展了其他成员，采用同样的规则。尽可能放在一行里，若是单行超出100字符，那就拆成如下的多行形式

class Person(
  name: String,
  age: Int,
  birthdate: Date,
  astrologicalSign: String,
  shoeSize: Int,
  favoriteColor: java.awt.Color,
) extends Entity
  with Logging
  with Identifiable
  with Serializable {

  def firstMethod: Foo = …
}

类中各元素的顺序

类、对象、特质中的所有成员之间一般都应当用一个空行隔开。对于val和var，如果定义足够简单（比如单行少于20字符）并且没有Scala Doc，那么多个val或var之间可以不加空行。

一般而言，字段定义应当在方法之前，但当字段求值是多行表达式的时候，此时字段实际上有点方法的味道了（例如在List上计算其长度）。这样的字段可以在文件靠后的位置，注意，仅限val和lazy val使用这一后放规则。注意千万不能把var在类里面放得遍地都是

方法

方法应当以def foo(bar: Baz): Bin = expr形式进行声明，若是方法参数有默认值，应当在等号两侧加空格。注意，应当对于所有公有成员声明返回类型，既能显式描述方法返回类型，也能避免编译器推断的返回类型在实现修改后发生变化，从而导致二进制不兼容。本地方法或私有方法可以不显式给出返回类型

过程式语法

编程实践中尽量不要用过程式语法

// don't do this
def printBar(bar: Baz) {
  println(bar)
}

// write this instead
def printBar(bar: Bar): Unit = {
  println(bar)
}

方法修饰符

对方法的修饰符应当按以下顺序。注解、每个注解单独一行；重写标识符override；访问控制修饰符protected、private；隐式关键字implicit；final关键字；def关键字

方法体

若是方法体只是一行简单表达式，那么不必用花括号包裹起来，若该表达式比较短（比如少于30字符），那么跟方法定义直接写在一行即可；该表达式比较长的话，那么就新起一行。具体选择哪种比较主观，总体思想是使代码可读性更好，若是方法声明很长但表达式很短，那也应当写在新一行里，避免使声明行过长。

对于仅有match表达式的方法，xx match {应与方法声明写在同一行。

方法体是多行表达式的时候，应注意必须用花括号。

多参数列表

应当仅在有着充分理由的时候使用该语言功能，一般而言，有以下三方面原因驱使编写该风格代码：Fluent API设计、隐式参数、为了更好的类型推断

// 自定义流程控制API
def unless(exp: Boolean)(code: => Unit): Unit = if (!exp) code

unless(x < 5) {
  println("x was not less than five")
}

// 对于多参数列表，给出第一个参数后，其余参数可以用编译器类型推断来简化编写

// scala中，一般这样定义
def fold[U](unit: U)(op: (U, A) => U): U
// 这样调用
List("").fold(0)(_ + _.length)

// 若是这样定义
def fold[U](unit: U, op: (U, A) => U): U
// 只能这样声明具体类型的调用
List("").foldLeft[Int](0, _ + _.length)
// 下面这种调用是不对的
List("").fold(0, (i: Int, s: String) => i + s.length)

对于复杂DSL或者类型名称超长的类型，可能很难在一行中完整声明整个函数签名，这种情况可以每个参数列表占一行，左括号对齐

高阶函数

在Scala中，只要在声明函数的时候稍微留心，那么调用高阶函数的时候可以有一些语法上的简化。考虑fold函数，SML中它的签名fun fold (f: ('b * 'a) -> 'b) (init: 'b) (ls: 'a list)，在Scala中，一般是相反的参数顺序def fold[A, B](ls: List[A])(init: B)(f: (B, A) => B): B = ...。把函数参数放在最后一个，那么调用该函数的时候，可以用上函数简化语法fold(List(1,2,3,4))(0)(_+_)

字段

字段遵循的声明规则跟方法大约一致。此外，对于lazy的字段，val必须紧跟lazy关键字

函数值

Scala允许多种语法声明函数值，例如，以下几种方式都是正确的

val f1 = ((a: Int, b: Int) => a + b)
val f2 = (a: Int, b: Int) => a + b
val f3 = (_: Int) + (_: Int)
val f4: (Int, Int) => Int = (_ + _)

其中，第一种和第四种方式是建议写法，第二种相对也还行，但是当函数体多行的时候容易出现问题；第三种是最简洁的，但是可能比较难以理解，尤其是一眼看上去可能看不懂，得想一下才能懂什么意思。

函数值中，在小括号和它们包裹代码之间不应当有空格，但花括号与其代码见应用空格。

大部分函数可能不像上例给出的那样简要，它们可能都是有多行表达式。这种情况下，就将函数切分到多行去，这种情况下必须用第一种风格

val f1 = { (a: Int, b: Int) =>
  val sum = a + b
  sum
}

此外，函数值的声明和调用都应尽可能发挥编译器类型推断的功能。

控制结构

CONTROL STRUCTURES

所有的控制结构关键词if/for/while之后都必须紧跟一个空格

花括号

当控制结构表达的是一个纯函数式操作并且各个分支都只是单行表达式时应当省略花括号

if表达式：若是存在else分支，则应当省略花括号；否则必须用花括号包裹起来，哪怕只有单行表达式
while：必须带上花括号（因为它永远不可能描述一个纯函数式操作）
for：若是有yield语句，那么可以省略花括号；否则必须用花括号包裹循环体，哪怕仅有一行表达式
case: 省略花括号

val news = if (foo)
  goodNews()
else
  badNews()

if (foo) {
  println("foo was true")
}

news match {
  case "good" => println("Good news!")
  case "bad" => println("Bad news!")
}

`for`-Comprehensions

在for语句中可以写多个生成器（即多个<-）对于存在yield语句的for表达式，当有多个生成器的时候，要用花括号包裹且每个生成器占一行；仅有一个生成器的时候，用小括号包裹，如下

// right
for (i <- 0 to 10) yield i

// wrong!
for (x <- board.rows; y <- board.files)
  yield (x, y)

// right!
for {
  x <- board.rows
  y <- board.files
} yield (x, y)

存在特例，对于那些没有yield的for表达式，这种情况属于普通的循环而不是函数式操作，此时使用小括号包裹一个或多个生成器

// wrong!
for {
  x <- board.rows
  y <- board.files
} {
  printf("(%d, %d)", x, y)
}

// right!
for (x <- board.rows; y <- board.files) {
  printf("(%d, %d)", x, y)
}

for-comprehensions可能会常倾向于链接map、flatMap、filter等调用，但是会导致代码可读性很差，因此这种情况要尽可能用增强的for表达式

细碎的条件判断

有些需要三元操作符?/:的场景，scala中无这样的操作符，但是可以直接用简单的if/else表达式来表述，例如val res = if (foo) bar else baz。要注意这种风格不要在命令式运用if/else时使用

方法调用

METHOD INVOCATION

简要来讲，Scala中的方法调用遵循Java风格的约定。在调用对象、点、方法名之间没有空格，方法名和参数列表之间没有空格，参数之间应当以逗号和一个空格隔开。

Scala 2.8开始支持了命名参数，进行方法调用时，命名参数整体应当看作一个普通参数（即逗号加一个空格分隔），命名参数自身等号两侧应当各有一个空格

foo(42, bar)
target.foo(42, bar)
target.foo()

foo(x = 6, y = 7)

0元函数/无参函数

Scala允许省略0元函数调用时的括号。当要调用的方法没有任何副作用的时候才能用这种语法，否则必须带上括号。

xx.toString()     // √
xx.toString       // √

println()         // √
println           // x

Postfix Notation/后缀写法

此外，对于无参数函数，Scala也允许采用后缀写法，但是要尽可能避免，这里只是给出了有这种写法，但是非常不建议使用。仅限在某些DSL中才允许用这种写法。

1
2

names.toList    
names toList    // x

1元函数/单个参数 - 中缀写法

对于这类函数，Scala允许一种完全无需任何符号的语法，即中缀写法。通常情况下，应当注意避免这种语法，但当方法名是个符号参数部分是个函数的时候可以用，当然也必须保证是在纯函数的环境中用。

1
2
3

names.mkString(",")     // √
names mkString ","      // 有时会见到这种写法，但这种写法存在争议，要避免
javaList add item       // x

符号方法、操作符

这种方法/函数必须要以中缀风格来进行调用。

"daniel" + " " + "spiewak"    // √
a + b                         // √

"daniel"+" "+"spiewak"        // x
a+b                           // x
a.+(b)                        // x

绝大多数情况下，遵循Java和Haskell中的约定。在某些灰色地带中，对那些方法名短小、实际效果类似操作符的函数，尤其是当它满足了交换律的时候，例如max，x max y这种写法也是相当常见的。

符号方法可能接受多个参数，这种情况下要用中缀语法来调用，foo ** (bar, baz)。这种方法其实相当少了，在设计API的时候应注意，尽可能避免设计出这样的API。Scala的集合API设计中存在/:和:\，尽量不要使用它们，转而使用更具意义的方法名foldLeft和foldRight。

高阶函数

对于那些接受一个函数为参数的方法，应尽量使用的中缀语法。但是用中缀语法的时候不要带着多余的符号了

1
2
3

names.map { _.toUpperCase }                           // x
names.map { _.toUpperCase }.filter { _.length > 5 }   // √
names map { _.toUpperCase } filter { _.length > 5 }   // √

文件

FILES

一般来讲，文件中应当只包含逻辑上的单个组件。所谓“逻辑上”的单个组件，指的是一个类型、特质或对象。当类或特质有其伴生对象时，要将伴生对象放在类或特质的同一文件中。文件名应当就是类、特质或对象的名称。此外，应当按照其包的结构放在相同目录结构中。

Scala放宽了对于文件名、目录结构的限制，但实际编程中还是应注意遵循Java风格的约定。

package com.novell.coolness

class Inbox { ... }

// companion object
object Inbox { ... }

多元素文件

有些很特殊的情况就是要违反以上约定。

一个很常见的例子便是对于封闭抽象类、封闭特质及其子类的实现（一般是对ADT相关功能的实现）。因为封闭类、特质从语言级别就约束了其子类必须与其在同一个源文件中。

sealed trait Option[+A]

case class Some[A](a: A) extends Option[A]

case object None extends Option[Nothing]

另一个常见场景是多个类从逻辑上很内聚，它们基于同样的一组前提或者概念，为方便维护便放在了同一个源文件中。这种情况确实存在，但应仔细斟酌是否放到一个源文件中

所有的多元素文件都必须以小驼峰给文件命名

例如option.scala、ast.scala

文档

SCALADOC

应当为所有的包、类、特质、方法及其他成员提供详细的文档。Scala文档遵循Java的文档风格，此外也提供了更丰富的功能用于简化文档的书写。

应当更关注文档的主旨和内容，而不是格式。文档以简短的概括开始，然后再给出更深入的细节描述。一下给出几种常见风格

// ---- Java doc 风格 ----

/**
 * Provides a service as described.
 *
 * This is further documentation of what we're documenting.
 * Here are more details about how it works and what it does.
 */
def member: Unit = ()

// ---- Scala doc 风格 （星号在第二列对齐） ----

/** Provides a service as described.
 *
 *  This is further documentation of what we're documenting.
 *  Here are more details about how it works and what it does.
 */
def member: Unit = ()

// ---- Scala doc 风格 （星号在第三列对齐） ----

/** Provides a service as described.
  *
  * This is further documentation of what we're documenting.
  * Here are more details about how it works and what it does.
  */
def member: Unit = ()

// ---- 某些特别简单的注释 ----

/** Does something very simple */
def simple: Unit = ()

SCALADOC FOR LIBRARY AUTHORS

Higher Kinded Type - 高阶类类型

Thu, 28 May 2020 00:00:00 +0800

Higher Kinded Type - 高阶类类型

Kind

维基百科：Kind (type theory)

“kind"中文翻译也是“类型”，这样就跟"type"有些混淆。下文仅将“type”翻译类型。

Kind是类型理论(Type Theory)中的定义。一个kind便是一个类型构造器的类型(the type of a type constructor)，或者说是高阶类型类型操作符的类型(the type of a higher-order type operator)。

Kind System本质上是简单类型Lambda演算(simply typed lambda calculus)的“上一层”。定义一个原始类型(primitive type)(记作*/$*$、称之为“type”)，它是任意数据类型(data type)的kind，不需要任何类型参数。

kind有个可能看上去有些莫名其妙的解释：“(数据)类型的类型”（type of a (data) type），但实际上它也有些元数指示的意思。从语法上讲，可以很自然地将多态类型视为类型构造器，因此非多态类型可以视为一个0元类型构造器/无参类型构造器，所有的无参类型构造器都是相同的、最简单的kind，便是*/$*$

高阶类型操作符在编程语言中并不常见，在大多数编程实践中，kind用于区分数据类型和用于实现参数化多态的构造器类型(types of constructors which are used to implement parametric polymorphism)。在类型系统使得用户能编码实现参数化多态的编程语言中(如C++ Haskell Scala)，或明或暗地有kind的概念存在。

Examples

*/$*$是所有数据类型的kind，读作"type”，也可看作0元类型构造器/无参类型构造器，在当前上下文中也称为恰当类型(proper type)，通常也包含函数式编程语言中的函数类型。例如Int/Bool/List<Int>/Map<String, List<Double>>的kind都是*
* -> */$* \rightarrow *$是一元类型构造器(unary type constructor)的kind。例List类型的kind便是* -> *，需要给出一个类型参数Int才能得到恰当类型List<Int>
* -> * -> */$* \rightarrow * \rightarrow *$是二元类型构造器(binary type constructor，curry方式实现)的kind。例如Tuple便是二元类型构造器；函数类型构造器->也属此类（注：对->应用的结果是函数类型，函数类型kind是*）
(* -> *) -> */$(* \rightarrow *) \rightarrow *$是从一元类型构造器到恰当类型的高阶类型操作符的kind

Values	Types	Kinds
`1`	`Int`	`*`
`[1,2,3]`	`List<Int>`	`*`
`(1, "")`	`Tuple<Int, String>`	`*`
`fun i -> i % 2 == 0`	`Int -> Bool`	`*`
-	`List`	`* -> *`
-	`Tuple`	`* -> * -> *`
-	`->`	`* -> * -> *`

从左向右提升抽象层次

Kind In Haskell

Haskell的Kind系统中，$K = * | K \rightarrow K$，它描述了两条规则：*/$*$是所有数据类型的kind；* -> */$* \rightarrow *$是一元类型构造器的kind，接受一个kind然后给出一个kind。

确实有值的类型才是算作具体类型，或者叫恰当类型。例如，4是Int类型的值、[1, 2, 3]是[Int]类型的值、fun i -> i % 2 == 0是Int -> Bool类型的值、fun x -> fun y -> x % y == 0是Int -> Int -> Bool类型的值。这些类型的kind都是*。

一个类型构造器接受一个或多个类型参数，当接受了足够的类型参数之后便产生了一个新类型(类型构造支持基于currying的偏应用)。例如，[]/List接受一个类型参数，这个类型参数指出了内部元素的类型，因此[Int]/[Bool]/[[Int]]都是对于[]的正确应用，[]的kind是* -> *，Int/Bool/[Int]的kind是*，将之应用到[]便得到[Int]/[Bool]/[[Int]]，这些结果类型的kind是*。同理，二元组类型构造器(,)的kind是* -> * -> *，三元组类型构造器(,,)的kind是* -> * -> * -> *

HKT in Programming

静态类型语言中，类型系统来保证值的使用安全性，kind系统是来保证类型的使用安全性。

主流编程语言中提供的一般是一阶参数化多态(first-order parametric polymorphism)，这一功能一般称为泛型(generic)。泛型能对类型进行抽象并进行静态检查，但无法对类型构造器进行抽象，进而无法保证这方面类型安全(不支持HKT的话也写不出来，因为编译器不接受这样的代码，只能舍弃抽象，从而导致代码重复)。

// ---------- Version 1 ----------
trait Iterable[T] {
    def filter(p: T => Boolean): Iterable[T]
    def remove(p: T => Boolean): Iterable[T] = filter(x => !p(x))
}

trait List[T] extends Iterable[T] {
    def filter(p: T => Boolean): List[T] = ???
    override def remove(p: T => Boolean): List[T] = filter(x => !p(x))
}
// ---------- Version 2 ----------
trait Iterable[T, Container[_]] {
    def filter(p: T => Boolean): Container[T]
    def remove(p: T => Boolean): Container[T] = filter(x => !p(x))
}

trait List[T] extends Iterable[T, List]

以上代码用Scala简单演示了引入HKT带来的收益，确实减少了不必要的代码重复，而对于类型安全的保证也不会有任何损失。下面是个稍复杂些的例子，用Haskell和Scala对函子进行定义和实现，从而对HKT进行演示。

-- Functor in Haskell
class Functor f where
    fmap :: (a -> b) -> f a -> f b

-- data Maybe a = Nothing | Just a
instance Functor Maybe where
    fmap _ Nothing = Nothing
    fmap f (Just x) = Just (f x)

-- data List a = Nil | Cons a (List a)
instance Functor List where
    fmap _ Nil = Nil
    fmap f (Cons x xs) = Cons (f x) (fmap f xs)

-- `(->)` is a type constructor. `(->) r a` => `r -> a`
-- here: `fmap :: (a -> b) -> (r -> a) -> (r -> b)`
instance Functor ((->) r) where
    fmap f g = f . g

// Functor in Scala
trait Functor[F[_]] {
    def fmap[A, B](f: A => B)(fa: F[A]): F[B]
}

object OptionFunctor extends Functor[Option] {
    def fmap[A, B](f: A => B)(a: Option[A]): Option[B] = {
        a match {
            case None => None
            case Some(x) => Some(f(x))
        }
    }
}

object ListFunctor extends Functor[List] {
    def fmap[A, B](f: A => B)(list: List[A]): List[B] = {
        list match {
            case Nil => Nil
            case head :: tail => f(head) :: fmap(f)(tail)
        }
    }
}

class FunctionFunctor[R] extends Functor[({type λ[A] = R => A})#λ] {
    def fmap[A, B](f: A => B)(g: R => A): R => B = {
        f compose g
    }
}

分析以上代码，定义函子Functor用到了参数f/F[_]，该参数是个类型构造器，其kind便是* -> *，于是函子Functor的kind便是(* -> *) -> *，这里便是kind的“高阶”所在。此外要注意函数类型构造(->)，对于其返回类型呈(协变)函子性，因此可以固定函数参数类型为r/R，然后可实现r -> ?/R => ?函子。Scala中需要显示指出类型构造器，Haskell可以通过对于参数的应用推断出这是个类型还是个类型构造器。

论文Generics of a Higher Kind解释了Scala对于HKT的设计及应用演示，论文中给出了一个更具实用意义的例子，通过对Iterable基础类库的设计和实现，演示了HKT存在的必要性（上文已简要演示）。此外也简要解释了Scala的“implicit”设计理念，该设计以另一种方式提供了Haskell的Type Class提供的特设多态(ad-hoc polymorphism)功能。此外，Scala的Kind System中，kind还附带着类型的上下界、可变性的约束信息，以此来确保程序的正确性。

F#尚不支持HKT，需要CLR改进才能支持这一功能，对功能的讨论在：Simulate higher-kinded polymorphism。Robert Kuzelj的Higher Kinded Types in F#系列博客演示了HKT存在的必要性以及在F#中如何对其进行模拟。

Higher Kinded Types in typescript博客介绍了在TypeScript中对HKT功能进行模拟。

Rust对HKT的似乎也开始支持，高阶类型 Higher Kinded Type对此进行了简单介绍，看评论似乎不是HKT完整支持。

F#-Notes-2 Imperative Programming

Mon, 16 Oct 2017 00:00:00 +0800

F#-Notes-2 Imperative Programming

F#不仅可以用于纯函数式编程，也可用于命令式编程。其实对于某些问题，命令式编程是一个十分行之有效的做法。

`unit` Type

对于某些方法，它不需要传入参数，也不会返回任何值，传入的参数和和返回值类型都是unit，有点类似C#中的void和CLR中的System.Void。对于函数式编程来说，如果一个函数没有接受值也没有返回值，那么它什么也没做；但是对于命令式编程，我们需要意识到副作用的存在，所以这类函数依旧有其作用的。unit是字面量()的类型，因此如果一个函数不接受值，不返回值，那么只需要在参数处和返回值处放上这它就好了。如下所示

1
2
3

let aFunction () = ()
// val: aFunction: unit -> unit
aFunction ()

也可以显式忽略某个函数的值

`1`	`aFunc() \|> ignore`

The `mutable` Keyword

1
2

let mutable word = "Hello"
word <- "World" // type should be same

Defining Mutable Records

1
2
3

type MutableRecord = {first: string; mutable second: string}
let tem = {first= ""; second=""}
tem.second <- ""

The Reference Type

F# 4.0 之前不能直接将mutable的值捕获到闭包里面

! 取值
:= 赋值

let totalArray () =
    // define an array literal
    let array = [| 1; 2; 3 |]
    // define a counter
    let total = ref 0
    // loop over the array
    for x in array do
        // keep a running total
        total := !total + x
    // print the total
    printfn "total: %i" !total

totalArray()

Array

// define an array literal
let rhymeArray =
    [|  "Went to market";
        "Stayed home";
        "Had roast beef";
        "Had none" |]

// unpack the array into identifiers
let firstPiggy = rhymeArray.[0]
let secondPiggy = rhymeArray.[1]
let thirdPiggy = rhymeArray.[2]
let fourthPiggy = rhymeArray.[3]

// update elements of the array
rhymeArray.[0] <- "Wee,"
rhymeArray.[1] <- "wee,"
rhymeArray.[2] <- "wee,"
rhymeArray.[3] <- "all the way home"

// 交错数组
// define a jagged array literal
let jagged = [| [| "one" |] ; [| "two" ; "three" |] |]
// unpack elements from the arrays
let singleDim = jagged.[0]
let itemOne = singleDim.[0]
let itemTwo = jagged.[1].[0]

// print some of the unpacked elements
printfn "%s %s" itemOne itemTwo

// 数组初始化
// an array of characters
let chars = [| '1' .. '9' |]

// an array of tuples of number, square
let squares =
    [| for x in 1 .. 9 -> x, x*x |]
// print out both arrays
printfn "%A" chars
printfn "%A" squares

// 数组切片
// 切片语法也可用于List
let arr = [|1; 3; 5; 7; 11; 13|]
let middle = arr.[1..4] // [|3; 5; 7; 11|]

let start = arr.[..3] // [|1; 3; 5; 7|]
let tail = arr.[1..] // [|3; 5; 7; 11; 13|]

let ocean = Array2D.create 100 100 0
// Create a ship:
for i in 3..6 do
    ocean.[i, 5] <- 1
// Pull out an area hit by a 'shell':
let hitArea = ocean.[2..5, 2..5]

// We can see a rectangular area by 'radar':
let radarArea = ocean.[3..4, *]

Control Flow

if x = 1 then
    printfn "eq"
else
    printfn "ne"

// an array for words
let words = [| "Red"; "Lorry"; "Yellow"; "Lorry" |]

// use a for loop to print each element
for word in words do
    printfn "%s" word

for index = 0 to Array.length words - 1 do
    printfn "%s" words.[index]

for index = Array.length words downto 0 do
    printfn "%s" words.[index]

let mutable tem = 10
while (tem > 0) do
    tem <- tem - 1

// Count upwards:
for i in 0..10 do
    printfn "%i green bottles" i

// Count downwards:
for i in 10..-1..0 do
    printfn "%i green bottles" i

// Count upwards in tens
for i in 0..10..100 do
    printfn "%i green bottles" i

Calling Static Methods and Properties from .NET Libraries

// calling static method
ClassName.MethodName(arg1, arg2, arg3)

// or in a curried way
let methodName arg1 arg2 arg3 =
    ClassName.MethodName(arg1, arg2, arg3)

let temMethod arg1 =
    methodName arg1

// named paramaters
open System.IO

// open a file using named arguments
let file = File.Open(path = "test.txt",
    mode = FileMode.Append,
    access = FileAccess.Write,
    share = FileShare.None)

// close it!
file.Close()

Using Objects and Instance Members from .NET Libraries

open System.IO
// file name to test
let filename = "test.txt"
// bind file to an option type, depending on whether
// the file exist or not
let file =
    if File.Exists(filename) then
        Some(new FileInfo(filename, Attributes = FileAttributes.ReadOnly))
    else
        None

open System
// how to wrap a method that take a delegate with an F# function
// the <_> means don't care the type of the Predicate's argument
let findIndex f arr = Array.FindIndex(arr, new Predicate<_>(f))
// define an array literal
let rhyme = [| "The"; "cat"; "sat"; "on"; "the"; "mat" |]
// print index of the first word ending in 'at'
printfn "First word ending in 'at' in the array: %i"
    (rhyme |> findIndex (fun w -> w.EndsWith("at")))

Using Indexers from .NET Libraries

open System.Collections.Generic
// create a ResizeArray
let stringList =
    let temp = new ResizeArray<string>()
    temp.AddRange([| "one"; "two"; "three" |]);
    temp
// unpack items from the resize array
let itemOne = stringList.Item(0)
let itemTwo = stringList.[1]
// print the unpacked items
printfn "%s %s" itemOne itemTwo

Working with Events from .NET Libraries

open System.Timers
let timedMessages() =
    // define the timer
    let timer = new Timer(Interval = 3000.0,
        Enabled = true)
    // a counter to hold the current message
    let mutable messageNo = 0

    // the messages to be shown
    let messages = [ "bet"; "this"; "gets";
            "really"; "annoying";
            "very"; "quickly" ]
    // add an event to the timer
    timer.Elapsed.Add(fun _ ->
        // print a message
        printfn "%s" messages.[messageNo]
        messageNo <- messageNo + 1
        if messageNo = messages.Length then
            timer.Enabled <- false)

timedMessages()

open System.Timers
let timedMessagesViaDelegate() =
    // define the timer
    let timer = new Timer(Interval = 3000.0,
        Enabled = true)
    // a counter to hold the current message number
    let mutable messageNo = 0
    // the messages to be shown
    let messages = [ "bet"; "this"; "gets";
        "really"; "annoying";
        "very"; "quickly" ]
    // function to print a message
    let printMessage = fun _ _ ->
        // print a message
        printfn "%s" messages.[messageNo]
        messageNo <- (messageNo + 1) % messages.Length
    // wrap the function in a delegate
    let del = new ElapsedEventHandler(printMessage)
    // add the delegate to the timer
    timer.Elapsed.AddHandler(del) |> ignore
    // return the time and the delegate so we can
    // remove one from the other later
    (timer, del)

// Run this first:
let timer, del = timedMessagesViaDelegate()

// Run this later:
timer.Elapsed.RemoveHandler(del)

Pattern Matching with .NET Types

// a list of objects
let simpleList = [ box 1; box 2.0; box "three" ]
// a function that pattern matches over the
// type of the object it is passed
let recognizeType (item : obj) =
    match item with
    | :? System.Int32 -> printfn "An integer"
    | :? System.Double -> printfn "A double"
    | :? System.String -> printfn "A string"
    | _ -> printfn "Unknown type"

// iterate over the list of objects
List.iter recognizeType simpleList

// list of objects
let anotherList = [ box "one"; box 2; box 3.0 ]
// pattern match and print value
let recognizeAndPrintType (item : obj) =
    match item with
    | :? System.Int32 as x -> printfn "An integer: %i" x
    | :? System.Double as x -> printfn "A double: %f" x
    | :? System.String as x -> printfn "A string: %s" x
    | x -> printfn "An object: %A" x

// iterate over the list pattern matching each item
List.iter recognizeAndPrintType anotherList

try
    // look at current time and raise an exception
    // based on whether the second is a multiple of 3
    if System.DateTime.Now.Second % 3 = 0 then
        raise (new System.Exception())
    else
        raise (new System.ApplicationException())
with
    | :? System.ApplicationException ->
        // this will handle "ApplicationException" case
        printfn "A second that was not a multiple of 3"
    | _ ->
        // this will handle all other exceptions
        printfn "A second that was a multiple of 3"

The `|>` Operator

1
2

// the definition of |>
let (|>) x f = f x

// grab a list of all methods in memory
let methods = System.AppDomain.CurrentDomain.GetAssemblies()
    |> List.ofArray
    |> List.map ( fun assm -> assm.GetTypes() )
    |> Array.concat
    |> List.ofArray
    |> List.map ( fun t -> t.GetMethods() )
    |> Array.concat

// print the list
printfn "%A" methods

Learn Windows PowerShell 3 in a Month of Lunches - Review lab 1 (chapters 1–6)

Mon, 14 Aug 2017 00:00:00 +0800

Learn Windows PowerShell 3 in a Month of Lunches - Review lab 1 (chapters 1–6)

NOTE: To complete this lab, you will need any computer running PowerShell v3. You should complete the labs in chapters 1 through 6 of this book prior to attempting this review lab.

HINTS :
- Sort-Object
- Select-Object
- Import-Module
- Export-CSV
- Help
- Get-ChildItem (Dir)

TASK 1

Run a command that will display the newest 100 entries from the Application event log. Do not use Get-WinEvent
1

Get-EventLog -LogName Application -Newest 10
TASK 2

Write a command line that displays only the five top processes based on virtual memory (VM) usage.
1

Get-Process | Sort-Object -Property VM -Descending | Select-Object -First 5
TASK 3

Create a CSV file that contains all services, including only the service names and statuses. Have running services listed before stopped services.
1

Get-Service | Sort-Object -Property Status -Descending | Select-Object -Property Name,Status | Export-Csv -Path C:\service.csv
TASK 4

Write a command line that changes the startup type of the BITS service to Manual
1

Set-Service -Name BITS -StartupType Manual
TASK 5

Display a list of all files named win. on your computer. Start in the C:\folder.

Note: you may need to experiment and use some new parameters of a cmdlet in order to complete this task.
1

Get-ChildItem C:\ -Filter win*.* -File -Recurse
TASK 6

Get a directory listing for C:\Program Files. Include all subfolders, and have the directory listing go into a text file named C:\Dir.txt (remember to use the > redirector, or the Out-File cmdlet).
1

Get-ChildItem 'C:\Program Files' -Recurse -Directory > C:\dir.txt
TASK 7

Get a list of the most recent 20 entries from the Security event log, and convert the information to XML . Do not create a file on disk: have the XML display in the console window.

Note that the XML may display as a single top-level object, rather than as raw XML data—that’s fine. That’s just how PowerShell displays XML . You can pipe the XML object to Format-Custom to see it expanded out into an object hierarchy, if you like.
1

Get-EventLog -LogName Security -Newest 20 | ConvertTo-Xml
TASK 8

Get a list of services, and export the data to a CSV file named C:\services.csv.
1

Get-Service | Export-Csv C:\services.csv
TASK 9

Get a list of services. Keep only the services’ names, display names, and statuses, and send that information to an HTML file. Have the phrase “Installed Services” displayed in the HTML file before the table of service information.
1

Get-Service | Select-Object -Property Name,Status,DisplayName | ConvertTo-Html -PreContent "Installed Services" | Out-File C:\services.html
TASK 10

Create a new alias, named D , which runs Get-ChildItem. Export just that alias to a file.

Now, close the shell and open a new console window. Import that alias into the shell.

Make sure you can run D and get a directory listing.
1 2 3 4

New-Alias -Name D -Value Get-ChildItem Export-Alias -Path C:\alias.xml -Name D # reopen ps Import-Alias -Path C:\alias.xml
TASK 11

Display a list of event logs that are available on your system.
1

Get-EventLog -List
TASK 12

Run a command that will display the current directory that the shell is in.
1 2 3 4 5

pwd # or Get-Location # or gl
TASK 13

Run a command that will display the most recent commands that you have run in the shell. Locate the command that you ran for task 11. Using two commands connected by a pipeline, rerun the command from task 11.

In other words, if Get-Something is the command that retrieves historical commands, if 5 is the ID number of the command from task 11, and Do-Something is the command that runs historical commands, run this:

Get-Something –id 5 | Do-Something

Of course, those aren’t the correct cmdlet names—you’ll need to find those. Hint: both commands that you need have the same noun.
1

Get-History -Id 6 | Invoke-History
TASK 14

Run a command that modifies the Security event log to overwrite old events as needed.
1

Limit-EventLog -LogName Security -OverflowAction OverwriteAsNeeded
TASK 15

Use the New-Item cmdlet to make a new directory named C:\Review. This is not the same as running Mkdir ; the New-Item cmdlet will need to know what kind of new item you want to create. Read the help for the cmdlet.
1

New-Item -Path C:\Review -ItemType Directory
TASK 16

Display the contents of this registry key: HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders

Note: “User Shell Folders” is not exactly like a directory. If you change into that “directory,” you won’t see anything in a directory listing. User Shell Folders is an item, and what it contains are item properties. There’s a cmdlet capable of displaying item properties (although cmdlets use singular nouns, not plural).
1

Get-ItemProperty 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders'
TASK 17

Find (but please do not run) cmdlets that can…
- Restart a computer
- Shut down a computer
- Remove a computer from a workgroup or domain
- Restore a computer’s System Restore checkpoint
1

help *computer*
TASK 18

What command do you think could change a registry value? Hint: it’s the same noun as the cmdlet you found for task 16.
1

Set-ItemProperty

CSS选择器

Sat, 29 Jul 2017 00:00:00 +0800

CSS 选择器

对CSS选择器的相关知识一直停留在有些印象的层面，到了用的时候还是要来金老师的网站翻PPT。虽然每次看一遍都觉得差不多了，但实际是代码写的太少，依旧是差得远了。对于html+css+js认知地水平还是很水的，也就是了解些基本的东西，任重道远。本文是对CSS选择器基本知识的复习（预习）。

基本选择器

标记选择器

设置HTML中某标签的样式

[label]{
    /*style content*/
}

/* for example */
p {
    color: red;
    font-size: 25px
}

/* use it
<p>This is a "p" label.</p>
*/

类别选择器

.[class-name] {
    /*style content*/
}

/* for example */
.red_large_text {
    color: red;
    font-size: 30px
}

/*
<p class="red_large_text">this is a paragraph.</p>
<a class="red_large_text" href="http://www.baidu.com">Baidu</a>
*/

ID选择器

#[id-name] {
    /* style content */
}

/* for example */
#copyright
{
    font-style:italic;
    font-size:16px;
}

/*
<div id="copyright">Copyright ..... </div>
*/

通用选择器

*是一个通配符，它匹配任何元素
1 2 3

* { /* style content */ }

复合选择器

将以上基本选择器组合应用

交集选择器

直接指定特定标记中，特定样式类或id的元素样式

[label-name][.[class-name]|#[id-name]] {
    /* style content */
    /* 选择器之间不能有字符 */
}

/* for example */
p.special{
    /* 标记.类别选择器 */
    color:red;
}

p#special{
    /* id选择器 */
    color:green;
}

/*
<p>
    本段未指定任何样式，以浏览器默认字体显示
</p>
<p class="special">
    本段指定了.special类别的样式，适用于交集选择器“p.special”，字体为红色
</p>
<p id="special">
    本段的id=special，适用于交集选择器“p#special”，字体为绿色
</p>
*/

并集选择器

一次定义多个标签或类别或ID的样式

[label],[.[class-name]],[#[id-name]] {
    /* style content */
    /* 以逗号隔开各个选择器 */
}

/* for example */
div,.special,#one {
    text-decoration:underline;
}

/* 凡是名字是<div>，其样式类名为special、id值为one的元素，其文本全都加上下划线 */

后代选择器

[label1] [label2] {
    /* style content */
    /* 以空格隔开各个选择器 */
    /* 设定存在于元素label1中元素label2的样式 */
}

[label1]>[label2] {
    /* style content */
    /* 设定存在于元素label1中元素label2的样式，而且必须是label1的直接子元素 */
}

/* for example */
p span{
    /*凡是<p>元素中的<span>元素，全部以红色显示。*/
    color:red;
}
div>h2 {
    /*只选择 h2 元素，并且这些元素都是 div 的 直接 子元素*/
    color:red;
}

兄弟选择器

[label1]+[label2] {
    /* style content */
    /* 选择label2元素，此元素是label1元素的弟弟（出现在label1下方），且是紧挨着的 */
}
[label1]~[label2] {
    /* style content */
    /* 选出所有label1的“弟弟”，不管是不是紧挨着的。 */
}

/* for example */

属性选择器

选择器	说明
`a[href]`	选择所有拥有指定href属性的a元素
`a[href="home.htm"]`	仅选择具有特定属性值的a元素
`img[alt~="thumbnail"]`	选择的img元素的alt属性中包容thumbnail单词（前后有空格）
`a[href^="http://"]`	选择所有href属性以“http://”开头的a元素
`a[href$=".pdf"]`	选择所有href属性以“.pdf”结尾的a元素
`div[id*="main"]`	选择所有id属性值包容“main”的所有div元素

伪类选择器

<a>的伪类

超链接标签<a>支持几个特殊的CSS样式类，用于定义超链接不同状态的样式，这些样式被称为伪类（pseudo class）

属性	说明
`a:link`	超链接的普通样式，即正常浏览状态的样式
`a:visited`	被点击之后的样式
`a:hover`	鼠标指针悬停在超链接元素之上时呈现的样式
`a:active`	单击超链接时呈现的样式

通用的伪类选择器

属性	说明
`:enabled`	元素激活时
`:disabled`	元素被屏蔽时
`:checked`	元素处于选中状态
`:focus`	元素拥有焦点时

伪类选择器的“条件运算”
- 伪类选择器支持not
  
  div:not(.myclass): 选择所有div元素，且其class属性不是myclass
- 可以连续使用多个not
  
  div:not(.myclass1):not(.myclass2): 选择所有div元素，其class属性不是.myclass1和.myclass2
- 可以使用其他条件
  
  div:not([id^=“main”]): 选择所有div元素，其id属性不是以main打头的
div:target

结构化选择器

与DOM密切相关

伪类选择器	说明
`:root`	选择根元素`<html>`
`:empty`	选择空元素，例如 `<p></p>`
`:first-child`	选择的元素是其父元素的第一个子元素
`:last-child`	选择的元素是其父元素的最后一个子元素
`:first-of-type`	指定元素类型的第一个儿子
`:last-of-type`	指定元素类型的最后一个儿子
`:only-child`	选中的元素是父元素的唯一儿子
`:only-of-type`	在父元素的所有儿子中，选择那些只有一个元素的元素类型

Nth类型选择器

选择器	说明
`:nth-child(n)`	第几个孩子
`:nth-last-child(n)`	倒数第几个孩子
`:nth-of-type(n)`	第几个元素类型
`:nth-last-of-type(n)`	倒数第几个元素类型

Nth类型支持简单的计算表达式

:nth-child(even)
:nth-child(odd)
:nth-child(an+b) a表示“步长”，为正表示向后，为负表示向前，b表示从第几个元素开始

伪元素

伪元素就是文档中若有实无的元素

::first-letter（首字母）和 ::first-line（首行）

p::first-letter {
    /*段落首字符放大3倍*/
    font-size:300%;
}

::before 和 ::after

p.age::before {
    content:"Age: ";
}
p.age::after {
    content:" years.";
}

/*
<p class="age">25</p>

显示效果：
Age: 25 years.
*/

继承与层叠原则

没有定义CSS规则的HTML元素从它的父元素中继承样式。

如果相互冲突：行内元素 > ID样式 > 类别样式 > 标签样式

F#-Notes-1 Functional Programming

Sun, 23 Jul 2017 00:00:00 +0800

F#-Notes-1 Functional Programming

在目前工作中，和看得见的之后吧。于我而言F#可能终归是一门用的少的语言，只能拿来当作兴趣的那种，而且身边也确实还没碰见对这门语言有兴趣的人，对它的学习和使用也总是会被打断。N久之后，虽然还记得一些思路上的东西，或者语言特性上的可能性，但是语法上的写法反而就这么忘记了，因此在此备忘一下。

此外还有十分重要的一点原因，实在是因为F# for fun and profit的离线版读到一半之后实在读不下去了（大约2000页，读到1200页左右），在Understanding Parser Combinators一章最终决定放弃这本书。有一说一，这本书确实很好，也很适合有C#、Java、Python基础的去读。但是对我而言，战线拉得过长了。在这一章节，回想以前的内容，只能有一些大致的印象了，而不是特别有把握地回想起某某某怎样怎样。

也可能是过于急于求成了，想要马上看到效果，欲速则不达。我这本F#的入门书其实看了可能有将近一年了吧？什么时候开始的已经忘记了，可能真的一年多了，到现在忘记了，很正常，毕竟平时并没有在使用。但是再次打开那个将近2000页的PDF也没有时间和勇气了，因此要按照“常规”的方式进行好了。

其实坦白来讲，似乎只需要一个F# Cheatsheet就够了，但是担心还是会有什么漏掉的，毕竟自己的F#目前就是个半瓶子水。还是重新来一遍吧。

内容参照《Beginning F# 4.0》进行整理，但是大致看一下这本书的目录，讲道理似乎不怎么样……嗯，同很多谈F#的编程书差不多，过于强调面向对象及命令式编程，而有些忽视F#基因中的味道，甚至对于更高级的内容避而不谈，这对于“关注语言特性”的我来说简直是个噩耗。不过也没有办法，目前这个工作强度，也确实没有大块时间去认真品味它，因此只能从皮毛入手了。算了不要在意这些细节，随缘好了。

也会迟疑，连个let a = 0这种水平的东西也要记下来，是不是真的有必要？毕竟这东西也太小白了不是。似乎我们对于自己已经会了的东西总是觉得很傻逼，可能是“会者不难、难者不会”，等到忘了还是得回来找，因此还是记下来吧，容易的简单写写就好了。

Literals

数值这边跟.NET基类库大致一一对应，包括字符串、字符、布尔、有/无符号（长/短）整型，单/双精度浮点型等等。此外F#还自行扩展出了Microsoft.FSharp.Math.BigInt Microsoft.FSharp.Math.BigNum（在F#中用bigint bignum）

Anonymous Functions

匿名函数（相对于具名函数而言），就是木有名字的函数了，也叫 lambda function(λ function)，或简称为lambda。

`1`	`fun x y -> x + y`

Identifiers and `let`/`use` Bindings

面对let a = 10这种表达式，很明显，这就是声明变量并初始化嘛。并不是，这是将值绑定到一个标识符，好吧场面上没什么区别的样子？要注意，a一旦被绑定，就不可变(因为它没有使用mutable显式声明可变)。此外在F#中，所有都是“值(Value)”，数值或者函数值，因此也可以将一个函数绑定到标识符上。

关于绑定函数，可以选择绑定lambda到一个标识符的写法，也可以选择“直接声明函数”式的写法。

一般绑定使用了let关键字，但是也有一个use关键字，它类似C#中的using，用于绑定需要尽快释放的资源。一旦脱离了use绑定的标识符的作用域，资源将会被自动释放。

F#中作用域(Scope)是通过缩进控制的，这很类似Python了，不过一般不太需要游标卡尺（吧……）。此外一些基本的东西在此处就可用了，比如内部的作用域可以捕获外部作用域的标识符等等，这很直观了。

let a = 10  // variable
let add = fun x y -> x + y   // anonymous function
let raisePowerTwo x = x ** 2.0  // function
open System.IO
// function to read first line from a file
let readFirstLine filename =
// open file using a "use" binding
    use file = File.OpenText filename
    file.ReadLine()
// call function and print the result
printfn "First line was: %s" (readFirstLine "mytext.txt")

Recursion

递归的话，需要使用rec关键字来显示声明此函数是递归的。

// assume x > 0
let rec fib x =
    match x with
    | 1 -> 1
    | 2 -> 1
    | x -> fib (x-1) + fib (x-2)

Operators

F#中操作符分“前缀操作符”和“中缀操作符”，好吧其实就是一元和二元了。操作符本质也是函数的体现，给操作符加上括号之后，就成为了一个函数，就能用应用函数的风格去使用。当然，也可以自定义操作符了，甚至重定义系统中存在的操作符。

1 + 1
(+) 1 1
let add = (+)
let ( +** ) x y = (x + y) * (x + y)

Function Application and Partial Application

应用一个函数的时候，可以一次性给出全部参数，也可以先给出部分参数，最终求值的时候凑齐全部参数，非常灵活。（只针对F#中定义的函数，对于其它非F#语言写的库，如果原生方式使用，必须一次性给出全部参数，而且必须用括号包起来，类似元组。当然，可以用F#包装一下原生方法，使之成为F#的函数）

let add x y = x + y
let result0 = add 4 5
let result1 = add 1 2 | add 3 | add 4

let add1 = add 1
let result2 = add1 2

Pattern Matching

模式匹配是超级超级强大的，思想上转变比较难的话，可以认为这是个牛逼版的switch语句。

关于它的花式运用直接看代码就好了，非常直观。

此外关注function关键字。

let rec luc x =
    match x with
    | x when x <= 0 -> failwith "value must be greater than 0"
    | 1 -> 1
    | 2 -> 3
    | x -> luc (x - 1) + luc (x - 2)

let booleanToString x =
    match x with false -> "False" | _ -> "True"

let stringToBoolean x =
    match x with
    | "True" | "true" -> true
    | "False" | "false" -> false
    | _ -> failwith "unexpected input"

let myOr b1 b2 =
    match b1, b2 with
    | true, _ -> true
    | _, true -> true
    | _ -> false

// function keyword
let boolToInt = function true -> 1 | false -> 0

let rec concatStringList =
    function
    | head :: tail -> head + concatStringList tail
    | [] -> ""

Control Flow

就是烂大街的if-else，一般来说更推荐上文模式匹配的写法。

let result =
    if System.DateTime.Now.Second % 2 = 0 then
        "heads"
    else
        "tails"

let result =
    match System.DateTime.Now.Second % 2 = 0 with
    | true -> "heads"
    | false -> "tails"

Type

F#是一门静态类型的强类型语言，它的的类型推断能力十分强大的，一般来说，如果不是为了特意限制，是不必加上类型限定符的。当然加上之后也无所谓了，下面的例子只是展示用法，并无太大实际意义，尤其是let绑定处的类型声明。

1
2
3

let doNothingToAnInt (x: int) = x
let intList = [1; 2; 3]
let (stringList: list<string>) = ["one"; "two"; "three"]

Defining Type

定义类型，在面向对象语言中似乎是语言学习的一个重点所在了，而在F#中，这只是非常小的一个方面了。而且下面要介绍的几个方面也是很小的一部分了。

F#中，类型定义大致分三类，元组/记录类型，联合体类型，类类型（后面讨论，面向对象部分），这里只谈前两个。

Tuple and Record Types

元组和记录型类型定义，没有太多不一样的地方了，看代码就好了

type Name = string
type Fullname = string * string

type Organization = { chief: string; indians: string list }
let wayneManor =
    { chief = "Batman";
        indians = ["Robin"; "Alfred"] }

Union Types

联合类型，某种程度上来说，类似C中的union吧，这个类型在F#中非常常见，与模式匹配互相组合能发挥巨大的作用。

type Volume =
    | Liter of float
    | UsPint of float
    | ImperialPint of float

let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint (2.5)

type Shape =
    | Square of side:float
    | Rectangle of width:float * height:float
    | Circle of radius:float

let S s =
    match s with
    | Square s -> s * 4.0
    | Rectangle (w, h) -> (w + h) * 2.0
    | Circle r -> System.Math.PI * r * 2.0

let sq = Square 1.2
let sq2 = Square(side=1.2)
let rect3 = Rectangle(height=3.4, width=1.2)

Generic (Type Definitions with Type Parameters)

类型参数化，或者说，泛型，是一个很普遍的技术了，在保证类型安全的前提下提升了代码复用。语法如下：

type 'a BinaryTree =
    | BinaryNode of 'a BinaryTree * 'a BinaryTree
    | BinaryValue of 'a
let tree1 =
    BinaryNode(
        BinaryNode ( BinaryValue 1, BinaryValue 2),
        BinaryNode ( BinaryValue 3, BinaryValue 4) )
type Tree<'a> =
    | Node of Tree<'a> list
    | Value of 'a
let tree2 =
    Node( [ Node( [Value "one"; Value "two"] ) ;
        Node( [Value "three"; Value "four"] ) ] )

Recursive Type Definitions

在F#中，对于类型、标识符的声明和使用顺序有严格规定，使用之前，前方必须有其声明。但是对于就是要互相使用的，就要使用特殊的语法进行处理。

// represents an XML attribute
type XmlAttribute =
    { AttribName: string;
        AttribValue: string; }

// represents an XML element
type XmlElement =
    { ElementName: string;
        Attributes: list<XmlAttribute>;
        InnerXml: XmlTree }
// represents an XML tree
and XmlTree =
    | Element of XmlElement
    | ElementList of list<XmlTree>  // or: ElementList of XmlTree list
    | Text of string
    | Comment of string
    | Empty

Active Patterns

主动匹配，允许我们对于输入的数据进行分类并分类命名，然后结合模式匹配表达式进行分别处理。

主动匹配分为完全主动匹配和部分主动匹配，他们可以在多处定义，然后在某个模式匹配表达式中同时使用上。

Complete Active Patterns

完全主动匹配就是对于输入的输入进行完全的分类，每个类型都显式给出一个名字，它跟部分主动匹配最大的不同就是：保证给出一个值。如下例

open System

// definition of the active pattern
let (|MyBoolean|MyInt|MyFloat|MyString|) input =
    let success, res = Boolean.TryParse input
    if success then MyBoolean(res)
    else
        let success, res = Int32.TryParse input
        if success then MyInt(res)
        else
            let success, res = Double.TryParse input
            if success then MyFloat(res)
            else MyString(input)

let printInputWithType input =
    match input with
    | MyBoolean b -> printfn "Boolean: %b" b
    | MyInt i -> printfn "Int: %i" i
    | MyFloat f -> printfn "Float: %f" f
    | MyString s -> printfn "String: %s" s

Partially Active Patterns

部分主动匹配可以用于测试某个输入是不是某个类型的值，如果是那么给出Some(Value)若不是，那么None

let (|Integer|_|) str =
    if str="" then Some(1)
    else None
let (|Float|_|) str =
    if str="." then Some(1.0)
    else None

let tem str =
    match str with
    | Integer i -> printf "%d" i
    | Float f -> printf "%f" f
    | _ -> printf "XXXXXX"

Units of Measure

测量单位是特意加入到F#的类型系统中的有趣特性。关于它的使用看语法就能明白了。

// define some units of measure
[<Measure>]type liter
[<Measure>]type pint

// define some volumes
let vol1 = 2.5<liter>
let vol2 = 2.5<pint>

// define the ratio of pints to liters
let ratio = 1.0<liter> / 1.76056338<pint>

// a function to convert pints to liters
let convertPintToLiter pints =
    pints * ratio

// perform the conversion and add the values
let newVol = vol1 + (convertPintToLiter vol2)

// stripping off unit of measure (<= F# 3.1)
printfn "The volume is %f" (float vol1)

// using a format placeholder with a unit-of-measure value (>= F# 4.0)
printfn "The volume is %f" vol1

Exceptions and Exception Handling

F#中的异常和异常处理跟C#还是有些不一样的地方的，可以使用exception关键字自定义异常，然后使用raise关键字触发引发一个异常，也可以使用failwith函数替代raise关键字。failwith函数一般用于引发一个普通的，带有文字描述的异常信息的异常，然后丢到上层去。

捕获异常不同类型，有些类似模式匹配了

此外，F#也支持try-finally结构，用于保证某些代码必定会执行（finally语句块无法和with语句块共存，或者说，没有提供try-with-finally语法，一般用try-finally嵌套try-with）

// define an exception type
exception WrongSecond of int

// list of prime numbers
let primes =
    [ 2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59 ]

// function to test if current second is prime
let testSecond() =
    try
        let currentSecond = System.DateTime.Now.Second in
        // test if current second is in the list of primes
        if List.exists (fun x -> x = currentSecond) primes then
            // use the failwith function to raise an exception
            failwith "A prime second"
        else
            // raise the WrongSecond exception
            raise (WrongSecond currentSecond)
    with
        // catch the wrong second exception
        WrongSecond x ->
            printf "The current was %i, which is not prime" x

// call the function
testSecond()

// try-finally
// function to write to a file
let writeToFile() =
    // open a file
    let file = System.IO.File.CreateText("test.txt")
    try
        // write to it
        file.WriteLine("Hello F# users")
    finally
        // close the file, this will happen even if
        // an exception occurs writing to the file
        file.Dispose()

// call the function
writeToFile()

Lazy Evaluation

标记为lazy的运算一旦被求值，就会将值缓存起来，下次被调用直接使用缓存的值。如果当中存在任何副作用（输出等），也只会体现一次。

let lazySideEffect =
    lazy(
        let temp = 2 + 2
        printfn "%i" temp
        temp)

printfn "Force value the first time: "
let actualValue1 = Lazy.force lazySideEffect
printfn "Force value the second time: "
let actualValue2 = Lazy.force lazySideEffect

let fibs =
    Seq.unfold
        (fun (x0, x1) ->
            Some(x0, (x1, x0+x1)))
        (1,1)

Seq.take 20 fibs

Language on boboboker~

泛型

泛型

基本语法

C#

泛型接口、泛型类和泛型方法

泛型委托和泛型事件

泛型数组

F#

Java

泛型约束

C#

泛型约束常规应用

default约束

关于?标注

关于歧义

消除歧义

unmanaged约束

委托约束

枚举约束

类型参数继承/实现声明的类/接口(F-Bound)

allows ref struct约束

F-Bound

可变性

C#

泛型接口/委托中的可变性

非泛型场景中的可变性

高阶泛型

Higher Kind

Higher Rank

参考链接

Java语言功能更新

Java语言功能更新

参考链接

Java 9

1. 接口中允许私有方法

2. 匿名内部类的钻石操作符

3. effectively-final变量在try-with-resources语句中可作为资源使用

4. 下划线不可作为标识符使用

5. 警告改进

Java 11 (LTS)

局部变量类型推断

Java 14

switch表达式

Java 15

1. 文本块

2. 携带详细信息的空指针异常

Java 16

1. 记录类

2. instanceof模式匹配

Java 17 (LTS)

封闭类

Java 21 (LTS)

1. switch模式匹配

2. 记录类模式

3. 其它预览功能

Scala Style

Scala Style

缩进和换行

命名约定

类、特质

对象

包

方法

Accessors/Mutators 属性访问器、修改器

无参方法/函数的括号

符号方法名

常量、值、变量和方法

类型参数（泛型）

HKT

注解

特别说明

类型

类型推断

类型注解

Type ascription / 类型归属？

函数

结构类型

嵌套代码块

代码块

`default`约束

关于`?`标注

`unmanaged`约束

`allows ref struct`约束

3. effectively-final变量在`try-with-resources`语句中可作为资源使用

`switch`表达式

2. `instanceof`模式匹配

1. `switch`模式匹配

`for`-Comprehensions

`unit` Type

The `mutable` Keyword

The `|>` Operator

Identifiers and `let`/`use` Bindings