仓颉编程语言特性随手记

  1. lambda
    1. 尾随lambda
    2. Flow 表达式
  2. Mut函数
  3. match
  4. if-let 模式
  5. while-let 模式
  • 泛型
  • 属性
  • 并发编程
    1. 原子操作 Atomic
    2. 可重入互斥锁ReentrantMutex
    3. 线程局部变量 ThreadLocal
  • lambda

    func f(a1!: (Int64) -> Int64): Int64 {
        return a1(1)
    }
    
    main() { var r1 = {a: String => println("hello ${a}")}
    r1("world") r1("baby")
    }

    lambda的好处:

    1. 简洁性:Lambda表达式提供了一种简洁的方式来定义匿名函数,即没有名称的函数。这有助于减少代码量,特别是在需要传递短小的函数作为参数时,使用lambda表达式可以使代码更加清晰易读。
    2. 局部作用域:Lambda表达式在其定义的上下文中执行,这意味着它们可以访问该上下文中的变量。这使得lambda表达式在处理需要访问局部变量的函数时非常有用。
    3. 方便使用高阶函数:在函数式编程语言中,函数常被当作参数传递给其他函数(高阶函数)。Lambda表达式提供了一种快速定义这类函数的方式,无需显式定义一个完整的函数。
    4. 快速实现接口方法:在一些支持lambda表达式的编程语言中,如Java和C#,lambda表达式可以用来快速实现只有一个方法的接口(这类接口通常称为函数式接口)。这使得代码更加简洁,同时减少了样板代码。
    5. 集合操作:在处理集合(如列表、集合等)时,lambda表达式常用于定义对集合元素的操作,如过滤、映射等。这使得集合操作更加灵活和强大。

    尾随lambda

    // 最后一个实参数是 lambda
    func myIf(a: Bool, fn: () -> Int64) {
        if (a) {
            println(fn())
        } else {
            println("Nothing")
        }
    }
    
    main() { // 正常表达方式 myIf(true, {=> 100})
    // 尾随表达方式,放到了圆括号外,不需要 => myIf(true) { 100 } }

    Flow 表达式

    • Pipeline表达形式

      func add(a: Int): Int {
          a + 1
      }
      
      func print_nx(a: Int): String { let res = "nx: ${a}" println(res) res }
      main() { // let v = e1; e2(v) 等价 100 |> print_nx
      let x = 1 let res = x |> add |> print_nx // 直接执行了 println(res) }
    • Composition表达形式

      func f(a: Int): Float64 {
          Float64(a)
      }
      
      func g(x: Float64): String { "float: ${x}" }
      main() { // { x => g(f(x)) } 等价 var fg = f ~> g // 组合起来了 println(fg(42)) }

    Mut函数

    只能用在struct里面,因为struct是值类型

    match

    必须穷尽

    main() {
        let x = 3
        match (x) {
            case 1 => let r1 = "x = 1"
                    print(r1)
            case 0 => let r2 = "x = 0"
                    print(r2)
            case _ => let r3 = "x = ?"
                    print(r3)
        }
    }
    
    • enum枚举要和match结合使用

      enum RGBColor {
          | Red(Int16) | Green(Int16) | Blue(Int16)
      }
      main() {
          let c = RGBColor.Green(-100)
          let cs = match (c) {
              case Red(r) where r < 0 => "Red = 0"
              case Red(r) => "Red = ${r}"
              case Green(g) where g < 0 => "Green = 0" // Matched.
              case Green(g) => "Green = ${g}"
              case Blue(b) where b < 0 => "Blue = 0"
              case Blue(b) => "Blue = ${b}"
          }
          print(cs)
      }
      
    • 没有匹配值的时候,case表示式为Bool

    • 绑定模式,最后一个可以是可变的(与enum模式互斥)

      main() {
          let x = 1
          let y = match (x) {
              case 0 => "zone"
              case 1 => "one"
              case n => "this is ${n}"
          }
          println(y)
      }
      
    • tuple 模式

      main() {
          let x = ("pf", 5, 30)
          let y = match (x) {
              case ("pf", 1, 30) => "111"
              case (n, 5, 30) => "who is ${n}"
              case (_, _, _) => "no body"
          }
          println(y)
      
      }

    if-let 模式

    在一些应用场景中,我们只关注一个表达式是否为某种特定模式,是则将其解构,取出对应值做相关操作。

    是对match的一种解构替代,不用全部覆盖

    // 用if来表示,方便
    main() {
        let x = TimeUnit.Year(2)
    
    if (let Year(n) <- x) { print("${x} is ${n} year") } }
    // 一种很方便确认是否有值的方式 let a: ?Int64 = 64
    if (let Some(n) <- a) { println(n) }

    while-let 模式

    from std import random.Random
    
    // 模拟取型号,有失败的场景 func recv(): Option<UInt8> { let number = Random().nextUInt8()
    if (number < 128) { return Some(number) } return None }
    main() { while (let Some(data) <- recv()) { // 取有值的数,很方便 println(data) } println("Done") }

    泛型

    泛型大多数要和约束配合使用,可以是类型约束,也可以是接口约束

    from std import collection.*
    
    abstract class Animal { public func run(): String }
    class Dog <: Animal { public func run(): String { return "dog run" } }
    class Fox <: Animal { public func run(): String { return "fox run" } }
    class Zoo<T> where T <: Animal { var animals: ArrayList<T> = ArrayList<T>()
    public func addAnimal(a: T) { animals.append(a) }
    public func allAnimalRun(): Unit { for (a in animals) { println(a.run()) } } }
    main() { var zoo: Zoo<Animal> = Zoo<Animal>() zoo.addAnimal(Dog()) zoo.addAnimal(Fox()) zoo.allAnimalRuns() return 0 }
    • 按照我的理解,类型泛型,表示的是这个类里面,所有不可知的类型,必须是从约束中出来的,否则编译不通过
      class Zoo {
          var animals: ArrayList<Animal> = ArrayList<Animal>()
      
      public func addAnimal(a: Animal) { animals.append(a) }
      public func allAnimalRun(): Unit { for (a in animals) { println(a.run()) } } }

    属性

    class Foo {
        private var _a = 0
    
    // mut 就是可改属性 public mut prop a: Int64 { get() {_a} set(v) {_a=v} } }
    main() { let f = Foo() let x = f.a + 1 f.a = x print(f.a) }
    • 也可以定义抽象属性

    并发编程

    from std import sync.sleep
    from std import time.Duration
    
    main() { let fut: Future<Int> = spawn { println("thread started, Thread is : ${Thread.currentThread.id}") sleep(Duration.millisecond) println("thread finished") return 64 }
    println("thread id : ${fut.thread.id}") let res: ?Int = fut.get(1000*1000*1000) match (res) { case Some(x) => println("result: ${x}") case None => println("timeout") } }

    原子操作 Atomic

    from std import sync.AtomicInt64
    from std import sync.sleep
    from std import time.Duration
    from std import collection.ArrayList
    
    main() { let counter = AtomicInt64(0) let list = ArrayList<Future<Int64>>()
    for (_ in 0..1000) { list.append(spawn { sleep(Duration.second) counter.fetchAdd(1) }) }
    for (i in list) { i.get() }
    println(counter.load()) }
    • 定义原子操作的类,支持Int, Bool类型
      AtomicInt 类型支持的操作:

    AtomicBool和AtomicReference支持的操作:

    可重入互斥锁ReentrantMutex

    可重入互斥锁的作用是对临界区加以保护,使得任意时刻最多只有一个线程能够执行临界区的代码。当一个线程试图获取一个已被其他线程持有的锁时,该线程会被阻塞,直到锁被释放,该线程才会被唤醒,可重入是指线程获取该锁后可再次获得该锁。

    from std import sync.sleep
    from std import sync.ReentrantMutex
    from std import collection.ArrayList
    from std import time.Duration
    
    // 需要是全局变量 var counter: Int64 = 0 let mtx = ReentrantMutex()
    main() { let list = ArrayList<Future<Unit>>()
    for (_ in 0..1000) { let fut = spawn { sleep(Duration.second) mtx.lock() counter++ mtx.unlock() } list.append(fut) }
    for (i in list) { i.get() }
    print("global counter: ${counter}") }

    当然,还有一种更加优雅的关键字来完成取锁和解锁,那就是synchronized

    synchronized(mtx) {
        counter++
    }
    

    线程局部变量 ThreadLocal

    安全的创建只属于线程的局部变量

    main() {
        let tl = ThreadLocal<Int64>() // 定义在主线程上的
        let fut1 = spawn {
            tl.set(123)
            println("tl in spawn1 = ${tl.get().getOrThrow()}")
        }
    
    let fut2 = spawn { tl.set(456) println("tl in spawn2 = ${tl.get().getOrThrow()}") }
    fut1.get() fut2.get() }

    转载请注明来源,欢迎对文章中的引用来源进行考证,欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 365433079@qq.com