modulepackage
0.0.0-20201021112637-66f189b4dfff
Repository: https://github.com/infinytum/reactive.git
Documentation: pkg.go.dev
# README
Reactive

My attempt on creating a simple RxJs clone
Features
- Observables
- Multi-Type support
- Subjects
- Subject
- ReplaySubject
- Pipes
- Take
- TakeEvery
- Skip
- SkipEvery
Examples
Simple Subject
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewSubject()
subject.Subscribe(subHandler)
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
1
2
3
4
Replay Subject
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewReplaySubject()
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Subscribe(subHandler)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
3
4
Multi-Type support
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewSubject()
subject.Subscribe(intHandler)
subject.Subscribe(stringHandler)
subject.Next(2)
subject.Next("Hello")
subject.Next("World")
subject.Next(4)
subject.Next(nil)
}
func intHandler(a int) {
fmt.Print("Int Handler: ")
fmt.Println(a)
}
func stringHandler(a string) {
fmt.Print("String Handler: ")
fmt.Println(a)
}
Output
Int Handler: 2
String Handler: Hello
String Handler: World
Int Handler: 4
Int Handler: 0
String Handler:
Take Pipe
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewReplaySubject()
subject.Pipe(reactive.Take(2)).Subscribe(subHandler)
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
1
2
TakeEvery Pipe
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewReplaySubject()
subject.Pipe(reactive.TakeEvery(2)).Subscribe(subHandler)
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
2
4
Skip Pipe
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewReplaySubject()
subject.Pipe(reactive.Skip(2)).Subscribe(subHandler)
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
3
4
SkipEvery Pipe
package main
import (
"github.com/infinytum/reactive"
"fmt"
)
func main() {
subject := reactive.NewReplaySubject()
subject.Pipe(reactive.SkipEvery(2)).Subscribe(subHandler)
subject.Next(1)
subject.Next(2)
subject.Next(3)
subject.Next(4)
}
func subHandler(a int) {
fmt.Println(a)
}
Output
$ go run main.go
1
3
# Functions
No description provided by the author
NewBufferSubject returns a pointer to an empty instance of bufferSubject.
NewReplaySubject returns a pointer to an empty instance of replaySubject.
NewSubject returns a pointer to an empty instance of subject.
NewSubscription generates a new subscription.
Skip will ignore a specified amount of updates and will pass through all following.
SkipEvery will skip every {count} update and will pass all others.
Take automatically unsubscribes an observable after the given amount of times it has been updated.
TakeEvery only passes every {count} update to the registered function.
# Interfaces
Observable defines the requirements for a class to be considered a valid observable.
Subjectable defines required methods for an object to be considered a subject.
# Type aliases
Pipe is the method signature for a pipe function.
Subscription represents a string to identify a subscription in an obserable so it can be removed.