func (o ObservableFloat64) Println(a ...interface{}) error {
	subscriber := subscriber.New()
	scheduler := scheduler.MakeTrampoline()
	observer := func(next float64, err error, done bool) {
		if !done {
			fmt.Println(append(a, next)...)
		} else {
			subscriber.Done(err)
		}
	}
	subscriber.OnWait(scheduler.Wait)
	o(observer, scheduler, subscriber)
	return subscriber.Wait()
}
jig:name ObservableFloat64_Println
Println subscribes to the Observable and prints every item to os.Stdout
while it waits for completion or error. Returns either the error or nil
when the Observable completed normally.
Println uses a trampoline scheduler created with scheduler.MakeTrampoline().
package AsObservable
import (
	"fmt"
	"github.com/reactivego/scheduler"
	"github.com/reactivego/subscriber"
)
type Scheduler = scheduler.Scheduler
type Subscriber = subscriber.Subscriber
type StringObserver func(next string, err error, done bool)
type ObservableString func(StringObserver, Scheduler, Subscriber)
func FromString(slice ...string) ObservableString {
	observable := func(observe StringObserver, scheduler Scheduler, subscriber Subscriber) {
		i := 0
		runner := scheduler.ScheduleRecursive(func(self func()) {
			if subscriber.Subscribed() {
				if i < len(slice) {
					observe(slice[i], nil, false)
					if subscriber.Subscribed() {
						i++
						self()
					}
				} else {
					var zero string
					observe(zero, nil, true)
				}
			}
		})
		subscriber.OnUnsubscribe(runner.Cancel)
	}
	return observable
}
type Observer func(next interface{}, err error, done bool)
type Observable func(Observer, Scheduler, Subscriber)
func From(slice ...interface{}) Observable {
	observable := func(observe Observer, scheduler Scheduler, subscriber Subscriber) {
		i := 0
		runner := scheduler.ScheduleRecursive(func(self func()) {
			if subscriber.Subscribed() {
				if i < len(slice) {
					observe(slice[i], nil, false)
					if subscriber.Subscribed() {
						i++
						self()
					}
				} else {
					var zero interface{}
					observe(zero, nil, true)
				}
			}
		})
		subscriber.OnUnsubscribe(runner.Cancel)
	}
	return observable
}
func (o ObservableString) AsObservable() Observable {
	observable := func(observe Observer, subscribeOn Scheduler, subscriber Subscriber) {
		observer := func(next string, err error, done bool) {
			observe(interface{}(next), err, done)
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
type Float64Observer func(next float64, err error, done bool)
type ObservableFloat64 func(Float64Observer, Scheduler, Subscriber)
type RxError string
func (e RxError) Error() string	{ return string(e) }
const TypecastFailed = RxError("typecast failed")
func (o Observable) AsObservableFloat64() ObservableFloat64 {
	observable := func(observe Float64Observer, subscribeOn Scheduler, subscriber Subscriber) {
		observer := func(next interface{}, err error, done bool) {
			if !done {
				if nextFloat64, ok := next.(float64); ok {
					observe(nextFloat64, err, done)
				} else {
					var zero float64
					observe(zero, TypecastFailed, true)
				}
			} else {
				var zero float64
				observe(zero, err, true)
			}
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
func (o Observable) Println(a ...interface{}) error {
	subscriber := subscriber.New()
	scheduler := scheduler.MakeTrampoline()
	observer := func(next interface{}, err error, done bool) {
		if !done {
			fmt.Println(append(a, next)...)
		} else {
			subscriber.Done(err)
		}
	}
	subscriber.OnWait(scheduler.Wait)
	o(observer, scheduler, subscriber)
	return subscriber.Wait()
}