624 lines
14 KiB
Go
624 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/goplus/llgo/x/async"
|
|
"github.com/goplus/llgo/x/async/naive"
|
|
"github.com/goplus/llgo/x/tuple"
|
|
)
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
func http(method string, url string, callback func(resp *Response, err error)) {
|
|
go func() {
|
|
body := ""
|
|
if strings.HasPrefix(url, "http://example.com/user/") {
|
|
name := url[len("http://example.com/user/"):]
|
|
body = `{"name":"` + name + `"}`
|
|
} else if strings.HasPrefix(url, "http://example.com/score/") {
|
|
body = "99.5"
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
resp := &Response{StatusCode: 200, Body: body}
|
|
callback(resp, nil)
|
|
}()
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
type Response struct {
|
|
StatusCode int
|
|
|
|
Body string
|
|
}
|
|
|
|
func (r *Response) Text() (co *async.Promise[tuple.Tuple2[string, error]]) {
|
|
co.Return(tuple.Tuple2[string, error]{V1: r.Body, V2: nil})
|
|
return
|
|
}
|
|
|
|
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(tuple.Tuple2[string, error]{V1: r.Body, V2: nil})
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
// async AsyncHttpGet(url string) (resp *Response, err error) {
|
|
// http("GET", url, func(resp *Response, err error) {
|
|
// return resp, err
|
|
// })
|
|
// }
|
|
func AsyncHttpGet(url string) *async.Promise[tuple.Tuple2[*Response, error]] {
|
|
co := &async.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) *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(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
|
|
})
|
|
co.Suspend()
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
func AsyncHttpPost(url string) *async.Promise[tuple.Tuple2[*Response, error]] {
|
|
co := &async.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) *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(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
|
|
})
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return P
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
type User struct {
|
|
Name string
|
|
}
|
|
|
|
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(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(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(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(tuple.Tuple2[User, error]{V1: User{}, V2: err})
|
|
return
|
|
}
|
|
|
|
// return user, nil
|
|
co.Return(tuple.Tuple2[User, error]{V1: user, V2: nil})
|
|
return
|
|
}
|
|
|
|
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 = &naive.PromiseImpl[tuple.Tuple2[User, error]]{}
|
|
co.Debug = "GetUser"
|
|
co.Func = func() {
|
|
switch co.Next {
|
|
case 0:
|
|
co.Next = 1
|
|
state1 = AsyncHttpGetCompiled("http://example.com/user/" + name)
|
|
state1.Exec = co.Exec
|
|
state1.Parent = co
|
|
state1.Call()
|
|
return
|
|
case 1:
|
|
co.Next = 2
|
|
resp, err := state1.Value().Values()
|
|
log.Printf("resp: %v, err: %v\n", resp, err)
|
|
if err != nil {
|
|
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
|
|
return
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
|
|
return
|
|
}
|
|
|
|
state2 = resp.TextCompiled()
|
|
state2.Exec = co.Exec
|
|
state2.Parent = co
|
|
state2.Call()
|
|
return
|
|
case 2:
|
|
co.Next = -1
|
|
body, err := state2.Value().Values()
|
|
if err != nil {
|
|
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(tuple.Tuple2[User, error]{V1: User{}, V2: err})
|
|
return
|
|
}
|
|
|
|
log.Printf("resolve user: %+v\n", user)
|
|
co.Return(tuple.Tuple2[User, error]{V1: user, V2: nil})
|
|
return
|
|
default:
|
|
panic(fmt.Errorf("Promise already done, %+v", co))
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetScore() (co *naive.PromiseImpl[tuple.Tuple2[float64, error]]) {
|
|
resp, err := AsyncHttpGet("http://example.com/score/").Await().Values()
|
|
if err != nil {
|
|
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(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(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(tuple.Tuple2[float64, error]{V1: 0, V2: err})
|
|
return
|
|
}
|
|
|
|
// return score, nil
|
|
co.Return(tuple.Tuple2[float64, error]{V1: score, V2: nil})
|
|
return
|
|
}
|
|
|
|
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 := &naive.PromiseImpl[tuple.Tuple2[float64, error]]{}
|
|
co.Debug = "GetScore"
|
|
co.Func = func() {
|
|
switch co.Next {
|
|
case 0:
|
|
co.Next = 1
|
|
state1 = AsyncHttpGetCompiled("http://example.com/score/")
|
|
state1.Exec = co.Exec
|
|
state1.Parent = co
|
|
state1.Call()
|
|
return
|
|
case 1:
|
|
co.Next = 2
|
|
|
|
resp, err := state1.Value().Values()
|
|
if err != nil {
|
|
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
|
|
return
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
|
|
return
|
|
}
|
|
|
|
state2 = resp.TextCompiled()
|
|
state2.Exec = co.Exec
|
|
state2.Parent = co
|
|
state2.Call()
|
|
|
|
return
|
|
case 2:
|
|
co.Next = -1
|
|
body, err := state2.Value().Values()
|
|
if err != nil {
|
|
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(tuple.Tuple2[float64, error]{V1: 0, V2: err})
|
|
return
|
|
}
|
|
co.Return(tuple.Tuple2[float64, error]{V1: score, V2: nil})
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
func DoUpdate(op string) (co *naive.PromiseImpl[error]) {
|
|
resp, err := AsyncHttpPost("http://example.com/update/" + op).Await().Values()
|
|
if err != nil {
|
|
co.Return(err)
|
|
return
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
co.Return(fmt.Errorf("http status code: %d", resp.StatusCode))
|
|
}
|
|
|
|
co.Return(nil)
|
|
return
|
|
}
|
|
|
|
func DoUpdateCompiled(op string) *naive.PromiseImpl[error] {
|
|
var state1 *naive.PromiseImpl[tuple.Tuple2[*Response, error]]
|
|
|
|
co := &naive.PromiseImpl[error]{}
|
|
co.Debug = "DoUpdate"
|
|
co.Func = func() {
|
|
switch co.Next {
|
|
case 0:
|
|
co.Next = 1
|
|
state1 = AsyncHttpPostCompiled("http://example.com/update/" + op)
|
|
state1.Exec = co.Exec
|
|
state1.Parent = co
|
|
state1.Call()
|
|
return
|
|
case 1:
|
|
co.Next = -1
|
|
resp, err := state1.Value().Values()
|
|
if err != nil {
|
|
co.Return(err)
|
|
return
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
co.Return(fmt.Errorf("http status code: %d", resp.StatusCode))
|
|
return
|
|
}
|
|
|
|
co.Return(nil)
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
func GenInts() (co *naive.PromiseImpl[int]) {
|
|
co.Yield(3)
|
|
co.Yield(2)
|
|
co.Yield(5)
|
|
return
|
|
}
|
|
|
|
func GenIntsCompiled() *naive.PromiseImpl[int] {
|
|
co := &naive.PromiseImpl[int]{}
|
|
co.Debug = "GenInts"
|
|
co.Func = func() {
|
|
switch co.Next {
|
|
case 0:
|
|
co.Next = 1
|
|
co.Yield(3)
|
|
return
|
|
case 1:
|
|
co.Next = 2
|
|
co.Yield(2)
|
|
return
|
|
case 2:
|
|
co.Next = 3
|
|
co.Yield(5)
|
|
return
|
|
case 3:
|
|
co.Next = -1
|
|
default:
|
|
panic("Generator already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
// Generator with async calls and panic
|
|
func GenUsers() (co *naive.PromiseImpl[User]) {
|
|
u, err := GetUser("Alice").Await().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
co.Yield(u)
|
|
u, err = GetUser("Bob").Await().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
co.Yield(u)
|
|
u, err = GetUser("Cindy").Await().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
co.Yield(u)
|
|
log.Printf("genUsers done\n")
|
|
return
|
|
}
|
|
|
|
func GenUsersCompiled() (resolve *naive.PromiseImpl[User]) {
|
|
var state1, state2, state3 *naive.PromiseImpl[tuple.Tuple2[User, error]]
|
|
|
|
co := &naive.PromiseImpl[User]{}
|
|
co.Debug = "GenUsers"
|
|
co.Func = func() {
|
|
switch co.Next {
|
|
case 0:
|
|
co.Next = 1
|
|
state1 = GetUserCompiled("Alice")
|
|
state1.Exec = co.Exec
|
|
state1.Parent = co
|
|
state1.Call()
|
|
return
|
|
case 1:
|
|
co.Next = 2
|
|
u, err := state1.Value().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
} else {
|
|
co.Yield(u)
|
|
}
|
|
return
|
|
case 2:
|
|
co.Next = 3
|
|
state2 = GetUserCompiled("Bob")
|
|
state2.Exec = co.Exec
|
|
state2.Parent = co
|
|
state2.Call()
|
|
return
|
|
case 3:
|
|
co.Next = 4
|
|
u, err := state2.Value().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
} else {
|
|
co.Yield(u)
|
|
}
|
|
return
|
|
case 4:
|
|
co.Next = 5
|
|
state3 = GetUserCompiled("Cindy")
|
|
state3.Exec = co.Exec
|
|
state3.Parent = co
|
|
state3.Call()
|
|
return
|
|
case 5:
|
|
co.Next = 6
|
|
u, err := state3.Value().Values()
|
|
if err != nil {
|
|
panic(err)
|
|
} else {
|
|
co.Yield(u)
|
|
}
|
|
return
|
|
case 6:
|
|
co.Next = -1
|
|
default:
|
|
panic("Generator already done")
|
|
}
|
|
}
|
|
return co
|
|
}
|
|
|
|
func Demo() (co *async.Promise[async.Void]) {
|
|
user, err := GetUser("1").Await().Values()
|
|
log.Println(user, err)
|
|
|
|
user, err = naive.Race[tuple.Tuple2[User, error]](GetUser("2"), GetUser("3"), GetUser("4")).Value().Values()
|
|
log.Println(user, err)
|
|
|
|
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, _ := naive.Await3Compiled[User, float64, async.Void](GetUser("8"), GetScore(), DoUpdate("update sth.")).Value().Values()
|
|
log.Println(user, score, err)
|
|
|
|
// for loop with generator
|
|
g := GenInts()
|
|
for {
|
|
g.Call()
|
|
if g.Done() {
|
|
break
|
|
}
|
|
log.Println("genInt:", g.Value(), g.Done())
|
|
}
|
|
|
|
// for loop with async generator
|
|
// for u, err := range GenUsers() {...}
|
|
g1 := GenUsers()
|
|
for {
|
|
g1.Call()
|
|
u := g1.Await()
|
|
if g1.Done() {
|
|
break
|
|
}
|
|
log.Println("genUser:", u, err)
|
|
}
|
|
|
|
// TODO(lijie): select from multiple promises without channel
|
|
// select {
|
|
// case user := <-GetUser("123").Chan():
|
|
// log.Println("user:", user)
|
|
// case score := <-GetScore().Chan():
|
|
// log.Println("score:", score)
|
|
// case <-async.Timeout(5 * time.Second).Chan():
|
|
// log.Println("timeout")
|
|
// }
|
|
|
|
log.Println("Demo done")
|
|
co.Return(async.Void{})
|
|
return
|
|
}
|
|
|
|
func DemoCompiled() *naive.PromiseImpl[async.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 := &naive.PromiseImpl[async.Void]{}
|
|
P.Debug = "Demo"
|
|
P.Func = func() {
|
|
switch P.Next {
|
|
case 0:
|
|
P.Next = 1
|
|
state1 = GetUserCompiled("1")
|
|
state1.Exec = P.Exec
|
|
state1.Parent = P
|
|
state1.Call()
|
|
return
|
|
case 1:
|
|
P.Next = 2
|
|
user, err := state1.Value().Values()
|
|
log.Printf("user: %+v, err: %v\n", user, err)
|
|
|
|
state2 = naive.Race[tuple.Tuple2[User, error]](GetUserCompiled("2"), GetUserCompiled("3"), GetUserCompiled("4"))
|
|
state2.Exec = P.Exec
|
|
state2.Parent = P
|
|
state2.Call()
|
|
return
|
|
case 2:
|
|
P.Next = 3
|
|
user, err := state2.Value().Values()
|
|
log.Printf("race user: %+v, err: %v\n", user, err)
|
|
|
|
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()
|
|
return
|
|
case 3:
|
|
|
|
P.Next = 4
|
|
users := state3.Value()
|
|
log.Println(users)
|
|
|
|
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()
|
|
return
|
|
case 4:
|
|
P.Next = 5
|
|
user, score, _ := state4.Value().Values()
|
|
log.Println(user, score)
|
|
|
|
g1 = GenIntsCompiled()
|
|
for {
|
|
g1.Call()
|
|
if g1.Done() {
|
|
break
|
|
}
|
|
|
|
log.Printf("genInt: %+v, done: %v\n", g1.Value(), g1.Done())
|
|
}
|
|
|
|
g2 = GenUsersCompiled()
|
|
g2.Exec = P.Exec
|
|
g2.Parent = P
|
|
g2.Call()
|
|
return
|
|
case 5:
|
|
g2.Call()
|
|
if g2.Done() {
|
|
P.Next = -1
|
|
log.Printf("Demo done\n")
|
|
P.Return(async.Void{})
|
|
return
|
|
}
|
|
log.Printf("genUser: %+v, done: %v\n", g2.Value(), g2.Done())
|
|
return
|
|
default:
|
|
panic("Promise already done")
|
|
}
|
|
}
|
|
return P
|
|
}
|
|
|
|
func main() {
|
|
log.SetFlags(log.Lshortfile | log.LstdFlags)
|
|
log.Printf("=========== Run Naive Demo ===========\n")
|
|
v := naive.RunImpl[async.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")
|
|
}
|