【华为鸿蒙开发技术】仓颉编程语言中的泛型指南

探索仓颉编程语言中的泛型

什么是泛型？

在编程中，泛型（Generics）是指参数化类型。简单来说，参数化类型就是在声明时类型未知，需要在使用时指定的类型。这种机制使得我们可以编写更通用和可复用的代码。在仓颉编程语言中，类型声明与函数声明都可以是泛型的，常见的例子包括 Array<T> 和 Set<T> 等容器类型。

仓颉中的泛型类型声明

在仓颉中，class、struct 与 enum 都可以声明类型形参，即它们可以是泛型的。以下是一些常用术语的定义：

• 类型形参：在声明时未知，需要在使用时指定的类型。
• 类型变元：在声明类型形参后，引用这些形参的标识符。
• 类型实参：在使用泛型类型或函数时，实际指定的类型。
• 类型构造器：需要类型实参的类型。

示例代码

class List<T> {
    var elem: Option<T> = None
    var tail: Option<List<T>> = None
}

func sumInt(a: List<Int64>) { }

在上述代码中，List<T> 中的 T 是类型形参，elem: Option<T> 中的 T 是类型变元，而 List<Int64> 中的 Int64 则是类型实参。List 是类型构造器，通过 Int64 类型实参构造出了一个类型 Int64 的列表类型。

泛型函数

如果一个函数声明了一个或多个类型形参，则该函数称为泛型函数。类型形参紧跟在函数名后，并用 <> 括起。例如：

func id<T>(a: T): T {
    return a
}

这是一个简单的泛型函数 id，它接受一个类型为 T 的参数，并返回同类型的值。以下是一个更复杂的泛型函数例子：

func composition<T1, T2, T3>(f: (T1) -> T2, g: (T2) -> T3): (T1) -> T3 {
    return {x: T1 => g(f(x))}
}

该函数将两个函数 f 和 g 复合成一个新函数。

泛型成员函数

类、结构体与枚举的成员函数也可以是泛型的。例如：

class A {
    func foo<T>(a: T): Unit where T <: ToString {
        println("${a}")
    }
}

struct B {
    func bar<T>(a: T): Unit where T <: ToString {
        println("${a}")
    }
}

enum C {
    | X | Y

    func coo<T>(a: T): Unit where T <: ToString {
        println("${a}")
    }
}

在上述代码中，A、B、C 的成员函数 foo、bar、coo 都是泛型函数，它们接受一个类型为 T 的参数，并要求 T 实现 ToString 接口。

静态泛型函数

静态泛型函数可以定义在 interface、class、struct、enum 和 extend 中。例如：

import std.collection.*

class ToPair {
    public static func fromArray<T>(l: ArrayList<T>): (T, T) {
        return (l[0], l[1])
    }
}

这段代码定义了一个静态泛型函数 fromArray，它接受一个 ArrayList 并返回一个包含前两个元素的元组。

泛型接口

泛型也可以用于定义接口，例如：

public interface Iterable<E> {
    func iterator(): Iterator<E>
}

public interface Iterator<E> <: Iterable<E> {
    func next(): Option<E>
}

public interface Collection<T> <: Iterable<T> {
     prop size: Int64
     func isEmpty(): Bool
}

在上述代码中，Iterator 和 Iterable 都是泛型接口，它们使用类型形参来表示元素的类型。

使用泛型的注意事项

在使用泛型时，需要注意以下几点：

1. 类型约束：有时我们需要对泛型参数进行约束，例如限制类型必须实现某个接口或继承某个类。仓颉使用 where 子句来指定类型约束。例如：

   class A {
       func foo<T>(a: T): Unit where T <: ToString {
           println("${a}")
       }
   }
   

   上面的代码表示 foo 函数的类型形参 T 必须实现 ToString 接口。

2. 类型擦除：在编译过程中，仓颉会进行类型擦除，即删除泛型类型的信息，以便生成更高效的字节码。因此，在运行时，泛型类型的信息会丢失。这意味着我们不能直接获取泛型类型的信息，例如：

   func printType<T>(a: T): Unit {
       println(typeOf(T)) // 编译错误
   }
   

   这种情况下，我们需要使用反射或其他机制来获取类型信息。

3. 泛型类型的实例化：由于类型擦除的存在，我们不能直接实例化泛型类型。例如：

   func createInstance<T>(): T {
       return new T() // 编译错误
   }
   

   这种情况下，我们需要通过工厂方法或传递类型实参的方式来创建实例。

实际应用

泛型在实际应用中非常有用，以下是一些常见的应用场景：

1. 容器类：如 List<T>、Set<T>、Map<K, V> 等，通过泛型使得容器类可以存储任意类型的对象，提高了代码的复用性和灵活性。

   var list: List<Int64> = List<Int64>()
   list.append(1)
   list.append(2)
   println(list) // 输出: [1, 2]
   

2. 算法：如排序、查找等算法，通过泛型使得算法可以处理任意类型的数据。

   func sort<T>(arr: ArrayList<T>): ArrayList<T> where T <: Comparable {
       // 实现排序算法
   }
   

3. 工具类：如泛型方法 max、min 等，通过泛型使得工具类的方法可以处理任意类型的数据。

   func max<T>(a: T, b: T): T where T <: Comparable {
       return a > b ? a : b
   }
   

泛型在仓颉中的高级用法

除了基础的泛型使用方式，仓颉还提供了一些高级用法，帮助开发者更加灵活地使用泛型。

1. 泛型与协变、逆变

协变和逆变是指在类型系统中，如何处理类型继承关系。在仓颉中，可以使用 + 和 - 符号来表示协变和逆变。

• 协变（Covariant）：使用 + 符号表示。如果 A 是 B 的子类型，那么 List<A> 是 List<B> 的子类型。

  interface Producer<+T> {
      func produce(): T
  }
  

• 逆变（Contravariant）：使用 - 符号表示。如果 A 是 B 的子类型，那么 Consumer<B> 是 Consumer<A> 的子类型。

  interface Consumer<-T> {
      func consume(value: T): Unit
  }
  

2. 泛型边界

泛型边界用于限制泛型参数的类型范围。例如，我们可以限制泛型参数必须实现某个接口或继承某个类。

func printToString<T>(item: T) where T <: ToString {
    println(item.toString())
}

在上述例子中，printToString 函数要求类型参数 T 必须实现 ToString 接口。

3. 多重泛型约束

仓颉允许对一个泛型参数设置多个约束。

func compareAndPrint<T>(a: T, b: T) where T <: Comparable, T <: ToString {
    if a > b {
        println("${a} is greater than ${b}")
    } else {
        println("${a} is not greater than ${b}")
    }
}

在这个例子中，类型参数 T 必须同时实现 Comparable 和 ToString 接口。

4. 泛型扩展

我们可以为已有的类型添加泛型扩展方法。

extend ArrayList {
    func findAll<T>(predicate: (T) -> Bool): ArrayList<T> where T <: this.Element {
        var result = ArrayList<T>()
        for elem in this {
            if predicate(elem) {
                result.append(elem)
            }
        }
        return result
    }
}

在上面的代码中，我们为 ArrayList 添加了一个泛型方法 findAll，该方法接受一个判断条件，并返回满足条件的元素列表。

示例项目：实现一个泛型缓存系统

让我们通过一个简单的示例项目来展示如何使用泛型实现一个缓存系统。

定义缓存接口

首先，我们定义一个缓存接口 Cache，该接口包含 get 和 put 方法。

public interface Cache<K, V> {
    func get(key: K): Option<V>
    func put(key: K, value: V): Unit
}

实现内存缓存

接下来，我们实现一个内存缓存 MemoryCache。

class MemoryCache<K, V>: Cache<K, V> {
    private var store: Map<K, V> = Map<K, V>()

    func get(key: K): Option<V> {
        return store.get(key)
    }

    func put(key: K, value: V): Unit {
        store.put(key, value)
    }
}

测试缓存系统

最后，我们编写一个测试函数来验证缓存系统的功能。

main() {
    var cache: Cache<String, Int64> = MemoryCache<String, Int64>()
    cache.put("one", 1)
    cache.put("two", 2)

    println(cache.get("one")) // 输出: Some(1)
    println(cache.get("two")) // 输出: Some(2)
    println(cache.get("three")) // 输出: None
}

在这个示例中，我们定义了一个泛型接口 Cache，并实现了一个简单的内存缓存 MemoryCache。通过泛型，我们可以轻松地创建不同类型的缓存，而无需重复编写相同的逻辑。

总结

泛型是一个强大的工具，它使得我们可以编写更加通用、灵活和可复用的代码。通过本文的介绍，希望大家能够对仓颉编程语言中的泛型有一个全面的了解，并能够在实际开发中熟练应用泛型。无论是定义泛型类型、泛型函数，还是泛型接口，泛型都能帮助我们简化代码、提高代码质量和开发效率。掌握泛型的使用，将会使你的编程技能更上一层楼。