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

# README

Reactive GoDoc Go Report Card Codacy Badge

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.