Added benchmark and comment about generic On/To pair

Changes

3 changed files (+87/-6)

• README.md
  • @@ -15,3 +15,28 @@
    ```go import "github.com/go-ap/activitypub" ``` + + ## Note about generics + + The helper functions exposed by the package come in two flavours: + explicit `OnXXX` and `ToXXX` functions corresponding to each type and, + a generic pair of functions `On[T]` and `To[T]`. + + Before using them you should consider that the former comes with a pretty heavy performance penalty: + + ``` + goos: linux + goarch: amd64 + pkg: github.com/go-ap/activitypub + cpu: Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz + Benchmark_OnT_vs_On_T/OnObject-8 752387791 1.633 ns/op + Benchmark_OnT_vs_On_T/On_T_Object-8 4656264 261.8 ns/op + Benchmark_OnT_vs_On_T/OnActor-8 739833261 1.596 ns/op + Benchmark_OnT_vs_On_T/On_T_Actor-8 4035148 301.9 ns/op + Benchmark_OnT_vs_On_T/OnActivity-8 751173854 1.604 ns/op + Benchmark_OnT_vs_On_T/On_T_Activity-8 4062598 285.9 ns/op + Benchmark_OnT_vs_On_T/OnIntransitiveActivity-8 675824500 1.640 ns/op + Benchmark_OnT_vs_On_T/On_T_IntransitiveActivity-8 4372798 274.1 ns/op + PASS + ok github.com/go-ap/activitypub 11.350s + ```
• helpers.go
  • @@ -55,17 +55,16 @@ }
    return fn(ob) } - func To[T Objects](it Item) (*T, error) { - ob, ok := it.(T) - if !ok { - return nil, fmt.Errorf("invalid cast for object %T", it) + func To[T Item](it Item) (*T, error) { + if ob, ok := it.(T); ok { + return &ob, nil } - return &ob, nil + return nil, fmt.Errorf("invalid cast for object %T", it) } // On handles in a generic way the call to fn(*T) if the "it" Item can be asserted to one of the Objects type. // It also covers the case where "it" is a collection of items that match the assertion. - func On[T Objects](it Item, fn func(*T) error) error { + func On[T Item](it Item, fn func(*T) error) error { if !IsItemCollection(it) { ob, err := To[T](it) if err != nil {
• helpers_test.go
  • @@ -319,3 +319,60 @@ }
    }) } } + + var fnObj = func(_ *Object) error { + return nil + } + var fnAct = func(_ *Actor) error { + return nil + } + var fnA = func(_ *Activity) error { + return nil + } + var fnIA = func(_ *IntransitiveActivity) error { + return nil + } + + func Benchmark_OnT_vs_On_T(b *testing.B) { + var it Item + b.Run("OnObject", func(b *testing.B) { + for i := 0; i < b.N; i++ { + OnObject(it, fnObj) + } + }) + b.Run("On_T_Object", func(b *testing.B) { + for i := 0; i < b.N; i++ { + On[Object](it, fnObj) + } + }) + b.Run("OnActor", func(b *testing.B) { + for i := 0; i < b.N; i++ { + OnActor(it, fnAct) + } + }) + b.Run("On_T_Actor", func(b *testing.B) { + for i := 0; i < b.N; i++ { + On[Actor](it, fnAct) + } + }) + b.Run("OnActivity", func(b *testing.B) { + for i := 0; i < b.N; i++ { + OnActivity(it, fnA) + } + }) + b.Run("On_T_Activity", func(b *testing.B) { + for i := 0; i < b.N; i++ { + On[Activity](it, fnA) + } + }) + b.Run("OnIntransitiveActivity", func(b *testing.B) { + for i := 0; i < b.N; i++ { + OnIntransitiveActivity(it, fnIA) + } + }) + b.Run("On_T_IntransitiveActivity", func(b *testing.B) { + for i := 0; i < b.N; i++ { + On[IntransitiveActivity](it, fnIA) + } + }) + }