157 lines
3.1 KiB
Go
157 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/goplus/llgo/x/async"
|
|
"github.com/goplus/llgo/x/async/timeout"
|
|
"github.com/goplus/llgo/x/tuple"
|
|
)
|
|
|
|
func ReadFile(fileName string) async.IO[tuple.Tuple2[[]byte, error]] {
|
|
return async.Async(func(resolve func(tuple.Tuple2[[]byte, error])) {
|
|
go func() {
|
|
bytes, err := os.ReadFile(fileName)
|
|
resolve(tuple.T2(bytes, err))
|
|
}()
|
|
})
|
|
}
|
|
|
|
func WriteFile(fileName string, content []byte) async.IO[error] {
|
|
return async.Async(func(resolve func(error)) {
|
|
go func() {
|
|
err := os.WriteFile(fileName, content, 0644)
|
|
resolve(err)
|
|
}()
|
|
})
|
|
}
|
|
|
|
func sleep(i int, d time.Duration) async.IO[int] {
|
|
return async.Async(func(resolve func(int)) {
|
|
async.BindIO(timeout.Timeout(d), func(async.Void) {
|
|
resolve(i)
|
|
})
|
|
})
|
|
}
|
|
|
|
func main() {
|
|
RunIO()
|
|
RunAllAndRace()
|
|
RunTimeout()
|
|
RunSocket()
|
|
}
|
|
|
|
func RunIO() {
|
|
println("RunIO with Await")
|
|
|
|
async.Run(func() {
|
|
content, err := async.Await(ReadFile("1.txt")).Get()
|
|
if err != nil {
|
|
fmt.Printf("read err: %v\n", err)
|
|
return
|
|
}
|
|
fmt.Printf("read content: %s\n", content)
|
|
err = async.Await(WriteFile("2.txt", content))
|
|
if err != nil {
|
|
fmt.Printf("write err: %v\n", err)
|
|
return
|
|
}
|
|
fmt.Printf("write done\n")
|
|
})
|
|
|
|
// Translated to in Go+:
|
|
println("RunIO with BindIO")
|
|
|
|
async.Run(func() {
|
|
async.BindIO(ReadFile("1.txt"), func(v tuple.Tuple2[[]byte, error]) {
|
|
content, err := v.Get()
|
|
if err != nil {
|
|
fmt.Printf("read err: %v\n", err)
|
|
return
|
|
}
|
|
fmt.Printf("read content: %s\n", content)
|
|
async.BindIO(WriteFile("2.txt", content), func(v error) {
|
|
err = v
|
|
if err != nil {
|
|
fmt.Printf("write err: %v\n", err)
|
|
return
|
|
}
|
|
fmt.Printf("write done\n")
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
func RunAllAndRace() {
|
|
ms100 := 100 * time.Millisecond
|
|
ms200 := 200 * time.Millisecond
|
|
ms300 := 300 * time.Millisecond
|
|
|
|
println("Run All with Await")
|
|
|
|
async.Run(func() {
|
|
all := async.All(sleep(1, ms200), sleep(2, ms100), sleep(3, ms300))
|
|
async.BindIO(all, func(v []int) {
|
|
fmt.Printf("All: %v\n", v)
|
|
})
|
|
})
|
|
|
|
println("Run Race with Await")
|
|
|
|
async.Run(func() {
|
|
first := async.Race(sleep(1, ms200), sleep(2, ms100), sleep(3, ms300))
|
|
v := async.Await(first)
|
|
fmt.Printf("Race: %v\n", v)
|
|
})
|
|
|
|
// Translated to in Go+:
|
|
|
|
println("Run All with BindIO")
|
|
|
|
async.Run(func() {
|
|
all := async.All(sleep(1, ms200), sleep(2, ms100), sleep(3, ms300))
|
|
async.BindIO(all, func(v []int) {
|
|
fmt.Printf("All: %v\n", v)
|
|
})
|
|
})
|
|
|
|
println("Run Race with BindIO")
|
|
|
|
async.Run(func() {
|
|
first := async.Race(sleep(1, ms200), sleep(2, ms100), sleep(3, ms300))
|
|
async.BindIO(first, func(v int) {
|
|
fmt.Printf("Race: %v\n", v)
|
|
})
|
|
})
|
|
}
|
|
|
|
func RunTimeout() {
|
|
println("Run Timeout with Await")
|
|
|
|
async.Run(func() {
|
|
fmt.Printf("Start 100 ms timeout\n")
|
|
async.Await(timeout.Timeout(100 * time.Millisecond))
|
|
fmt.Printf("timeout\n")
|
|
})
|
|
|
|
// Translated to in Go+:
|
|
|
|
println("Run Timeout with BindIO")
|
|
|
|
async.Run(func() {
|
|
fmt.Printf("Start 100 ms timeout\n")
|
|
async.BindIO(timeout.Timeout(100*time.Millisecond), func(async.Void) {
|
|
fmt.Printf("timeout\n")
|
|
})
|
|
})
|
|
}
|
|
|
|
func RunSocket() {
|
|
// async.Run(func() {
|
|
// tcp := io.NewTcp()
|
|
// tcp.
|
|
// })
|
|
}
|