lambda
func f(a1!: (Int64) -> Int64): Int64 {
return a1(1)
}
main() {
var r1 = {a: String => println("hello ${a}")}
r1("world")
r1("baby")
}
lambda的好处:
- 简洁性:Lambda表达式提供了一种简洁的方式来定义匿名函数,即没有名称的函数。这有助于减少代码量,特别是在需要传递短小的函数作为参数时,使用lambda表达式可以使代码更加清晰易读。
- 局部作用域:Lambda表达式在其定义的上下文中执行,这意味着它们可以访问该上下文中的变量。这使得lambda表达式在处理需要访问局部变量的函数时非常有用。
- 方便使用高阶函数:在函数式编程语言中,函数常被当作参数传递给其他函数(高阶函数)。Lambda表达式提供了一种快速定义这类函数的方式,无需显式定义一个完整的函数。
- 快速实现接口方法:在一些支持lambda表达式的编程语言中,如Java和C#,lambda表达式可以用来快速实现只有一个方法的接口(这类接口通常称为函数式接口)。这使得代码更加简洁,同时减少了样板代码。
- 集合操作:在处理集合(如列表、集合等)时,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