admin/llgo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

asyncio: refactor

Browse Source
This commit is contained in:
Li Jie
2024-07-29 15:42:00 +08:00
parent a578155dcb
commit 375b2b579e
5 changed files with 372 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
x/io/_demo/asyncdemo/async.go
View File

@@ -8,6 +8,8 @@ import (
"time"
"github.com/goplus/llgo/x/io"
"github.com/goplus/llgo/x/io/naive"
"github.com/goplus/llgo/x/tuple"
)
// -----------------------------------------------------------------------------
@@ -35,22 +37,19 @@ type Response struct {
Body string
}
func (r *Response) Text() *io.Promise[io.R2[string, error]] {
co := &io.Promise[io.R2[string, error]]{}
co.Func = func() {
co.Return(io.R2[string, error]{V1: r.Body, V2: nil})
}
return co
func (r *Response) Text() (co *io.Promise[tuple.Tuple2[string, error]]) {
co.Return(tuple.Tuple2[string, error]{V1: r.Body, V2: nil})
return
}
func (r *Response) TextCompiled() *io.Promise[io.R2[string, error]] {
co := &io.Promise[io.R2[string, error]]{}
func (r *Response) TextCompiled() *naive.PromiseImpl[tuple.Tuple2[string, error]] {
co := &naive.PromiseImpl[tuple.Tuple2[string, error]]{}
co.Debug = "Text"
co.Func = func() {
switch co.Next {
case 0:
co.Next = -1
co.Return(io.R2[string, error]{V1: r.Body, V2: nil})
co.Return(tuple.Tuple2[string, error]{V1: r.Body, V2: nil})
return
default:
panic("Promise already done")
@@ -59,26 +58,31 @@ func (r *Response) TextCompiled() *io.Promise[io.R2[string, error]] {
return co
}
func AsyncHttpGet(url string) *io.Promise[io.R2[*Response, error]] {
co := &io.Promise[io.R2[*Response, error]]{}
co.Func = func() {
http("GET", url, func(resp *Response, err error) {
co.Return(io.R2[*Response, error]{V1: resp, V2: nil})
})
}
// async AsyncHttpGet(url string) (resp *Response, err error) {
// http("GET", url, func(resp *Response, err error) {
// return resp, err
// })
// }
func AsyncHttpGet(url string) *io.Promise[tuple.Tuple2[*Response, error]] {
co := &io.Promise[tuple.Tuple2[*Response, error]]{}
http("GET", url, func(resp *Response, err error) {
co.Return(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
})
co.Suspend()
return co
}
func AsyncHttpGetCompiled(url string) *io.Promise[io.R2[*Response, error]] {
co := &io.Promise[io.R2[*Response, error]]{}
func AsyncHttpGetCompiled(url string) *naive.PromiseImpl[tuple.Tuple2[*Response, error]] {
co := &naive.PromiseImpl[tuple.Tuple2[*Response, error]]{}
co.Debug = "HttpGet"
co.Func = func() {
switch co.Next {
case 0:
co.Next = -1
http("GET", url, func(resp *Response, err error) {
co.Return(io.R2[*Response, error]{V1: resp, V2: nil})
co.Return(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
})
co.Suspend()
return
default:
panic("Promise already done")
@@ -87,25 +91,24 @@ func AsyncHttpGetCompiled(url string) *io.Promise[io.R2[*Response, error]] {
return co
}
func AsyncHttpPost(url string) *io.Promise[io.R2[*Response, error]] {
co := &io.Promise[io.R2[*Response, error]]{}
co.Func = func() {
http("POST", url, func(resp *Response, err error) {
co.Return(io.R2[*Response, error]{V1: resp, V2: nil})
})
}
func AsyncHttpPost(url string) *io.Promise[tuple.Tuple2[*Response, error]] {
co := &io.Promise[tuple.Tuple2[*Response, error]]{}
http("POST", url, func(resp *Response, err error) {
co.Return(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
})
co.Suspend()
return co
}
func AsyncHttpPostCompiled(url string) *io.Promise[io.R2[*Response, error]] {
P := &io.Promise[io.R2[*Response, error]]{}
func AsyncHttpPostCompiled(url string) *naive.PromiseImpl[tuple.Tuple2[*Response, error]] {
P := &naive.PromiseImpl[tuple.Tuple2[*Response, error]]{}
P.Debug = "HttpPost"
P.Func = func() {
switch P.Next {
case 0:
P.Next = -1
http("POST", url, func(resp *Response, err error) {
P.Return(io.R2[*Response, error]{V1: resp, V2: nil})
P.Return(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
})
return
default:
@@ -121,43 +124,43 @@ type User struct {
Name string
}
func GetUser(name string) (co *io.Promise[io.R2[User, error]]) {
func GetUser(name string) (co *naive.PromiseImpl[tuple.Tuple2[User, error]]) {
resp, err := AsyncHttpGet("http://example.com/user/" + name).Await().Values()
if err != nil {
// return User{}, err
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
if resp.StatusCode != 200 {
// return User{}, fmt.Errorf("http status code: %d", resp.StatusCode)
co.Return(io.R2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
return
}
body, err := resp.Text().Await().Values()
if err != nil {
// return User{}, err
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
user := User{}
if err := json.Unmarshal([]byte(body), &user); err != nil {
// return User{}, err
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
// return user, nil
co.Return(io.R2[User, error]{V1: user, V2: nil})
co.Return(tuple.Tuple2[User, error]{V1: user, V2: nil})
return
}
func GetUserCompiled(name string) (co *io.Promise[io.R2[User, error]]) {
var state1 *io.Promise[io.R2[*Response, error]]
var state2 *io.Promise[io.R2[string, error]]
func GetUserCompiled(name string) (co *naive.PromiseImpl[tuple.Tuple2[User, error]]) {
var state1 *naive.PromiseImpl[tuple.Tuple2[*Response, error]]
var state2 *naive.PromiseImpl[tuple.Tuple2[string, error]]
co = &io.Promise[io.R2[User, error]]{}
co = &naive.PromiseImpl[tuple.Tuple2[User, error]]{}
co.Debug = "GetUser"
co.Func = func() {
switch co.Next {
@@ -173,12 +176,12 @@ func GetUserCompiled(name string) (co *io.Promise[io.R2[User, error]]) {
resp, err := state1.Value().Values()
log.Printf("resp: %v, err: %v\n", resp, err)
if err != nil {
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
if resp.StatusCode != 200 {
co.Return(io.R2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
return
}
@@ -191,18 +194,18 @@ func GetUserCompiled(name string) (co *io.Promise[io.R2[User, error]]) {
co.Next = -1
body, err := state2.Value().Values()
if err != nil {
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
user := User{}
log.Printf("body: %v\n", body)
if err := json.Unmarshal([]byte(body), &user); err != nil {
co.Return(io.R2[User, error]{V1: User{}, V2: err})
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
return
}
log.Printf("resolve user: %+v\n", user)
co.Return(io.R2[User, error]{V1: user, V2: nil})
co.Return(tuple.Tuple2[User, error]{V1: user, V2: nil})
return
default:
panic(fmt.Errorf("Promise already done, %+v", co))
@@ -211,43 +214,43 @@ func GetUserCompiled(name string) (co *io.Promise[io.R2[User, error]]) {
return
}
func GetScore() (co *io.Promise[io.R2[float64, error]]) {
func GetScore() (co *naive.PromiseImpl[tuple.Tuple2[float64, error]]) {
resp, err := AsyncHttpGet("http://example.com/score/").Await().Values()
if err != nil {
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
if resp.StatusCode != 200 {
// return 0, fmt.Errorf("http status code: %d", resp.StatusCode)
co.Return(io.R2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
return
}
body, err := resp.Text().Await().Values()
if err != nil {
// return 0, err
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
score := 0.0
if _, err := fmt.Sscanf(body, "%f", &score); err != nil {
// return 0, err
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
// return score, nil
co.Return(io.R2[float64, error]{V1: score, V2: nil})
co.Return(tuple.Tuple2[float64, error]{V1: score, V2: nil})
return
}
func GetScoreCompiled() *io.Promise[io.R2[float64, error]] {
var state1 *io.Promise[io.R2[*Response, error]]
var state2 *io.Promise[io.R2[string, error]]
func GetScoreCompiled() *naive.PromiseImpl[tuple.Tuple2[float64, error]] {
var state1 *naive.PromiseImpl[tuple.Tuple2[*Response, error]]
var state2 *naive.PromiseImpl[tuple.Tuple2[string, error]]
co := &io.Promise[io.R2[float64, error]]{}
co := &naive.PromiseImpl[tuple.Tuple2[float64, error]]{}
co.Debug = "GetScore"
co.Func = func() {
switch co.Next {
@@ -263,12 +266,12 @@ func GetScoreCompiled() *io.Promise[io.R2[float64, error]] {
resp, err := state1.Value().Values()
if err != nil {
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
if resp.StatusCode != 200 {
co.Return(io.R2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
return
}
@@ -282,16 +285,16 @@ func GetScoreCompiled() *io.Promise[io.R2[float64, error]] {
co.Next = -1
body, err := state2.Value().Values()
if err != nil {
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
score := 0.0
if _, err := fmt.Sscanf(body, "%f", &score); err != nil {
co.Return(io.R2[float64, error]{V1: 0, V2: err})
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
return
}
co.Return(io.R2[float64, error]{V1: score, V2: nil})
co.Return(tuple.Tuple2[float64, error]{V1: score, V2: nil})
return
default:
panic("Promise already done")
@@ -300,7 +303,7 @@ func GetScoreCompiled() *io.Promise[io.R2[float64, error]] {
return co
}
func DoUpdate(op string) (co *io.Promise[error]) {
func DoUpdate(op string) (co *naive.PromiseImpl[error]) {
resp, err := AsyncHttpPost("http://example.com/update/" + op).Await().Values()
if err != nil {
co.Return(err)
@@ -315,10 +318,10 @@ func DoUpdate(op string) (co *io.Promise[error]) {
return
}
func DoUpdateCompiled(op string) *io.Promise[error] {
var state1 *io.Promise[io.R2[*Response, error]]
func DoUpdateCompiled(op string) *naive.PromiseImpl[error] {
var state1 *naive.PromiseImpl[tuple.Tuple2[*Response, error]]
co := &io.Promise[error]{}
co := &naive.PromiseImpl[error]{}
co.Debug = "DoUpdate"
co.Func = func() {
switch co.Next {
@@ -351,15 +354,15 @@ func DoUpdateCompiled(op string) *io.Promise[error] {
return co
}
func GenInts() (co *io.Promise[int]) {
func GenInts() (co *naive.PromiseImpl[int]) {
co.Yield(3)
co.Yield(2)
co.Yield(5)
return
}
func GenIntsCompiled() *io.Promise[int] {
co := &io.Promise[int]{}
func GenIntsCompiled() *naive.PromiseImpl[int] {
co := &naive.PromiseImpl[int]{}
co.Debug = "GenInts"
co.Func = func() {
switch co.Next {
@@ -385,7 +388,7 @@ func GenIntsCompiled() *io.Promise[int] {
}
// Generator with async calls and panic
func GenUsers() (co *io.Promise[User]) {
func GenUsers() (co *naive.PromiseImpl[User]) {
u, err := GetUser("Alice").Await().Values()
if err != nil {
panic(err)
@@ -405,10 +408,10 @@ func GenUsers() (co *io.Promise[User]) {
return
}
func GenUsersCompiled() (resolve *io.Promise[User]) {
var state1, state2, state3 *io.Promise[io.R2[User, error]]
func GenUsersCompiled() (resolve *naive.PromiseImpl[User]) {
var state1, state2, state3 *naive.PromiseImpl[tuple.Tuple2[User, error]]
co := &io.Promise[User]{}
co := &naive.PromiseImpl[User]{}
co.Debug = "GenUsers"
co.Func = func() {
switch co.Next {
@@ -469,17 +472,17 @@ func GenUsersCompiled() (resolve *io.Promise[User]) {
return co
}
func Demo() {
func Demo() (co *io.Promise[io.Void]) {
user, err := GetUser("1").Await().Values()
log.Println(user, err)
user, err = io.Race[io.R2[User, error]](GetUser("2"), GetUser("3"), GetUser("4")).Value().Values()
user, err = naive.Race[tuple.Tuple2[User, error]](GetUser("2"), GetUser("3"), GetUser("4")).Value().Values()
log.Println(user, err)
users := io.All[io.R2[User, error]]([]io.AsyncCall[io.R2[User, error]]{GetUser("5"), GetUser("6"), GetUser("7")}).Value()
users := naive.All[tuple.Tuple2[User, error]]([]naive.AsyncCall[tuple.Tuple2[User, error]]{GetUser("5"), GetUser("6"), GetUser("7")}).Value()
log.Println(users, err)
user, score, _ := io.Await3Compiled[User, float64, io.Void](GetUser("8"), GetScore(), DoUpdate("update sth.")).Value().Values()
user, score, _ := naive.Await3Compiled[User, float64, io.Void](GetUser("8"), GetScore(), DoUpdate("update sth.")).Value().Values()
log.Println(user, score, err)
// for loop with generator
@@ -496,8 +499,8 @@ func Demo() {
// for u, err := range GenUsers() {...}
g1 := GenUsers()
for {
g.Call()
u, err := io.Await[int](g)
g1.Call()
u := g1.Await()
if g1.Done() {
break
}
@@ -513,17 +516,21 @@ func Demo() {
// case <-io.Timeout(5 * time.Second).Chan():
// log.Println("timeout")
// }
log.Println("Demo done")
co.Return(io.Void{})
return
}
func DemoCompiled() *io.Promise[io.Void] {
var state1 *io.Promise[io.R2[User, error]]
var state2 *io.Promise[io.R2[User, error]]
var state3 *io.Promise[[]io.R2[User, error]]
var state4 *io.Promise[io.R3[io.R2[User, error], io.R2[float64, error], error]]
var g1 *io.Promise[int]
var g2 *io.Promise[User]
func DemoCompiled() *naive.PromiseImpl[io.Void] {
var state1 *naive.PromiseImpl[tuple.Tuple2[User, error]]
var state2 *naive.PromiseImpl[tuple.Tuple2[User, error]]
var state3 *naive.PromiseImpl[[]tuple.Tuple2[User, error]]
var state4 *naive.PromiseImpl[tuple.Tuple3[tuple.Tuple2[User, error], tuple.Tuple2[float64, error], error]]
var g1 *naive.PromiseImpl[int]
var g2 *naive.PromiseImpl[User]
P := &io.Promise[io.Void]{}
P := &naive.PromiseImpl[io.Void]{}
P.Debug = "Demo"
P.Func = func() {
switch P.Next {
@@ -539,7 +546,7 @@ func DemoCompiled() *io.Promise[io.Void] {
user, err := state1.Value().Values()
log.Printf("user: %+v, err: %v\n", user, err)
state2 = io.Race[io.R2[User, error]](GetUserCompiled("2"), GetUserCompiled("3"), GetUserCompiled("4"))
state2 = naive.Race[tuple.Tuple2[User, error]](GetUserCompiled("2"), GetUserCompiled("3"), GetUserCompiled("4"))
state2.Exec = P.Exec
state2.Parent = P
state2.Call()
@@ -549,7 +556,7 @@ func DemoCompiled() *io.Promise[io.Void] {
user, err := state2.Value().Values()
log.Printf("race user: %+v, err: %v\n", user, err)
state3 = io.All[io.R2[User, error]]([]io.AsyncCall[io.R2[User, error]]{GetUserCompiled("5"), GetUserCompiled("6"), GetUserCompiled("7")})
state3 = naive.All[tuple.Tuple2[User, error]]([]naive.AsyncCall[tuple.Tuple2[User, error]]{GetUserCompiled("5"), GetUserCompiled("6"), GetUserCompiled("7")})
state3.Exec = P.Exec
state3.Parent = P
state3.Call()
@@ -560,7 +567,7 @@ func DemoCompiled() *io.Promise[io.Void] {
users := state3.Value()
log.Println(users)
state4 = io.Await3Compiled[io.R2[User, error], io.R2[float64, error], error](GetUserCompiled("8"), GetScoreCompiled(), DoUpdateCompiled("update sth."))
state4 = naive.Await3Compiled[tuple.Tuple2[User, error], tuple.Tuple2[float64, error], error](GetUserCompiled("8"), GetScoreCompiled(), DoUpdateCompiled("update sth."))
state4.Exec = P.Exec
state4.Parent = P
state4.Call()
@@ -604,7 +611,13 @@ func DemoCompiled() *io.Promise[io.Void] {
func main() {
log.SetFlags(log.Lshortfile | log.LstdFlags)
// io.Run(Demo())
v := io.Run[io.Void](DemoCompiled())
log.Printf("=========== Run Naive Demo ===========\n")
v := naive.RunImpl[io.Void](DemoCompiled())
log.Println(v)
log.Printf("=========== Run Naive Demo finished ===========\n")
log.Printf("=========== Run Demo ===========\n")
v1 := Demo()
log.Println(v1)
log.Printf("=========== Run Demo finished ===========\n")
}