func (o Observable) AsObservableTimestampTime() ObservableTimestampTime {
	observable := func(observe TimestampTimeObserver, subscribeOn Scheduler, subscriber Subscriber) {
		observer := func(next interface{}, err error, done bool) {
			if !done {
				if nextTimestampTime, ok := next.(TimestampTime); ok {
					observe(nextTimestampTime, err, done)
				} else {
					var zero TimestampTime
					observe(zero, TypecastFailed, true)
				}
			} else {
				var zero TimestampTime
				observe(zero, err, true)
			}
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
jig:name Observable_AsObservableTimestampTime
AsObservableTimestampTime turns an Observable of interface{} into an ObservableTimestampTime.
If during observing a typecast fails, the error ErrTypecastToTimestampTime will be
emitted.
package Timestamp
import (
	"fmt"
	"time"
	"github.com/reactivego/scheduler"
	"github.com/reactivego/subscriber"
)
type TimestampTime struct {
	Value		Time
	Timestamp	time.Time
}
type Time = time.Time
type Scheduler = scheduler.Scheduler
type Subscriber = subscriber.Subscriber
type TimeObserver func(next Time, err error, done bool)
type ObservableTime func(TimeObserver, Scheduler, Subscriber)
func Ticker(initialDelay time.Duration, intervals ...time.Duration) ObservableTime {
	observable := func(observe TimeObserver, subscribeOn Scheduler, subscriber Subscriber) {
		i := 0
		runner := subscribeOn.ScheduleFutureRecursive(initialDelay, func(self func(time.Duration)) {
			if subscriber.Subscribed() {
				if i == 0 || (i > 0 && len(intervals) > 0) {
					observe(subscribeOn.Now(), nil, false)
				}
				if subscriber.Subscribed() {
					if len(intervals) > 0 {
						self(intervals[i%len(intervals)])
					} else {
						if i == 0 {
							self(0)
						} else {
							var zero time.Time
							observe(zero, nil, true)
						}
					}
				}
				i++
			}
		})
		subscriber.OnUnsubscribe(runner.Cancel)
	}
	return observable
}
func (o ObservableTime) Timestamp() ObservableTimestampTime {
	observable := func(observe TimestampTimeObserver, subscribeOn Scheduler, subscriber Subscriber) {
		observer := func(next Time, err error, done bool) {
			if subscriber.Subscribed() {
				if !done {
					observe(TimestampTime{next, subscribeOn.Now()}, nil, false)
				} else {
					var zero TimestampTime
					observe(zero, err, done)
				}
			}
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
type TimestampTimeObserver func(next TimestampTime, err error, done bool)
type ObservableTimestampTime func(TimestampTimeObserver, Scheduler, Subscriber)
func (o Observable) Take(n int) Observable {
	observable := func(observe Observer, subscribeOn Scheduler, subscriber Subscriber) {
		taken := 0
		observer := func(next interface{}, err error, done bool) {
			if taken < n {
				observe(next, err, done)
				if !done {
					taken++
					if taken >= n {
						observe(nil, nil, true)
					}
				}
			}
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
func (o ObservableTimestampTime) Take(n int) ObservableTimestampTime {
	return o.AsObservable().Take(n).AsObservableTimestampTime()
}
type Observer func(next interface{}, err error, done bool)
type Observable func(Observer, Scheduler, Subscriber)
func (o ObservableTimestampTime) AsObservable() Observable {
	observable := func(observe Observer, subscribeOn Scheduler, subscriber Subscriber) {
		observer := func(next TimestampTime, err error, done bool) {
			observe(interface{}(next), err, done)
		}
		o(observer, subscribeOn, subscriber)
	}
	return observable
}
func (o ObservableTimestampTime) All(predicate func(next TimestampTime) bool) ObservableBool {
	condition := func(next interface{}) bool {
		return predicate(next.(TimestampTime))
	}
	return o.AsObservable().All(condition)
}
type BoolObserver func(next bool, err error, done bool)
type ObservableBool func(BoolObserver, Scheduler, Subscriber)
type RxError string
func (e RxError) Error() string	{ return string(e) }
const TypecastFailed = RxError("typecast failed")