How to use has method of gop Package

...454`)455}456func TestErrMember(t *testing.T) {457	codeErrorTest(t,458		`./bar.gop:3:6: a.x undefined (type string has no field or method x)`,459		`460a := "Hello"461b := a.x462`)463}464func TestErrMemberRef(t *testing.T) {465	codeErrorTest(t,466		`./bar.gop:3:1: a.x undefined (type string has no field or method x)`,467		`468a := "Hello"469a.x = 1470`)471	codeErrorTest(t,472		`./bar.gop:5:1: a.x undefined (type aaa has no field or method x)`,473		`474type aaa byte475a := aaa(0)476a.x = 1477`)478	codeErrorTest(t,479		`./bar.gop:5:1: a.z undefined (type aaa has no field or method z)`,480		`481type aaa struct {x int; y string}482a := aaa{}483a.z = 1484`)485	codeErrorTest(t,486		`./bar.gop:3:1: a.z undefined (type struct{x int; y string} has no field or method z)`,487		`488a := struct{x int; y string}{}489a.z = 1490`)491}492func TestErrLabel(t *testing.T) {493	codeErrorTest(t,494		`./bar.gop:4:1: label foo already defined at ./bar.gop:2:1495./bar.gop:2:1: label foo defined and not used`,496		`x := 1497foo:498	i := 1499foo:500	i++...

...97			y := f(details[1])98			if diffTheme == nil {99				return j(x, k("not =="), y)100			}101			if hasNewline(x, y) {102				df := diff.Format(diff.Tokenize(ctx, gop.StripANSI(x), gop.StripANSI(y)), diffTheme)103				return j(x, k("not =="), y, df)104			}105			dx, dy := diff.TokenizeLine(ctx, gop.StripANSI(x), gop.StripANSI(y))106			return diff.Format(dx, diffTheme) + k("not ==") + diff.Format(dy, diffTheme)107		},108		AssertionNeqSame: func(details ...interface{}) string {109			x := f(details[0])110			y := f(details[1])111			return j(x, k("=="), y)112		},113		AssertionNeq: func(details ...interface{}) string {114			x := f(details[0])115			y := f(details[1])116			return j(x, k("=="), y, k("when converted to the same type"))117		},118		AssertionGt: func(details ...interface{}) string {119			x := f(details[0])120			y := f(details[1])121			return j(x, k("not >"), y)122		},123		AssertionGte: func(details ...interface{}) string {124			x := f(details[0])125			y := f(details[1])126			return j(x, k("not ≥"), y)127		},128		AssertionLt: func(details ...interface{}) string {129			x := f(details[0])130			y := f(details[1])131			return j(x, k("not <"), y)132		},133		AssertionLte: func(details ...interface{}) string {134			x := f(details[0])135			y := f(details[1])136			return j(x, k("not ≤"), y)137		},138		AssertionInDelta: func(details ...interface{}) string {139			x := f(details[0])140			y := f(details[1])141			delta := f(details[2])142			return j(k("delta between"), x, k("and"), y, k("not ≤"), delta)143		},144		AssertionTrue: func(_ ...interface{}) string {145			return k("should be") + f(true)146		},147		AssertionFalse: func(_ ...interface{}) string {148			return k("should be") + f(false)149		},150		AssertionNil: func(details ...interface{}) string {151			last := f(details[0])152			return j(k("last argument"), last, k("should be"), f(nil))153		},154		AssertionNoArgs: func(_ ...interface{}) string {155			return k("no arguments received")156		},157		AssertionNotNil: func(_ ...interface{}) string {158			return k("last argument shouldn't be") + f(nil)159		},160		AssertionNotNilable: func(details ...interface{}) string {161			last := f(details[0])162			return j(k("last argument"), last, k("is not nilable"))163		},164		AssertionNotNilableNil: func(details ...interface{}) string {165			last := f(details[0])166			return j(k("last argument"), last, k("shouldn't be"), f(nil))167		},168		AssertionZero: func(details ...interface{}) string {169			x := f(details[0])170			return j(x, k("should be zero value for its type"))171		},172		AssertionNotZero: func(details ...interface{}) string {173			x := f(details[0])174			return j(x, k("shouldn't be zero value for its type"))175		},176		AssertionRegex: func(details ...interface{}) string {177			pattern := f(details[0])178			str := f(details[1])179			return j(pattern, k("should match"), str)180		},181		AssertionHas: func(details ...interface{}) string {182			container := f(details[0])183			str := f(details[1])184			return j(container, k("should has"), str)185		},186		AssertionLen: func(details ...interface{}) string {187			actual := f(details[0])188			l := f(details[1])189			return k("expect len") + actual + k("to be") + l190		},191		AssertionErr: func(details ...interface{}) string {192			last := f(details[0])193			return j(k("last value"), last, k("should be <error>"))194		},195		AssertionPanic: func(_ ...interface{}) string {196			return k("should panic")197		},198		AssertionIsInChain: func(details ...interface{}) string {199			x := f(details[0])200			y := f(details[1])201			return j(x, k("should in chain of"), y)202		},203		AssertionIsKind: func(details ...interface{}) string {204			x := f(details[0])205			y := f(details[1])206			return j(x, k("should be kind of"), y)207		},208		AssertionCount: func(details ...interface{}) string {209			n := f(details[0])210			count := f(details[1])211			return k("should count") + n + k("times, but got") + count212		},213	}214	return &defaultAssertionError{fns: fns}215}216// Report interface217func (ae *defaultAssertionError) Report(ac *AssertionCtx) string {218	return ae.fns[ac.Type](ac.Details...)219}220func j(args ...string) string {221	if hasNewline(args...) {222		for i := 0; i < len(args); i++ {223			args[i] = strings.Trim(args[i], " ")224		}225		return "\n" + strings.Join(args, "\n\n")226	}227	return strings.Join(args, "")228}229func hasNewline(args ...string) bool {230	for _, arg := range args {231		if strings.Contains(arg, "\n") {232			return true233		}234	}235	return false236}...

...67	for i, l := range lines {68		if !keep[i] {69			continue70		}71		if _, has := keep[i-1]; !has {72			ts := []*Token{{ChunkStart, "@@ diff chunk @@"}, {Newline, "\n"}}73			out = append(out, &TokenLine{ChunkStart, ts})74		}75		out = append(out, l)76		if _, has := keep[i+1]; !has {77			ts := []*Token{{ChunkEnd, ""}, {Newline, "\n"}}78			out = append(out, &TokenLine{ChunkEnd, ts})79		}80	}81	return out82}83// Words diff84func Words(ctx context.Context, lines []*TokenLine) {85	delLines := []*TokenLine{}86	addLines := []*TokenLine{}87	df := func() {88		if len(delLines) == 0 || len(delLines) != len(addLines) {89			return90		}...

1import (2type gop struct {3}4func (g gop) has() {5    fmt.Println("gop has")6}7func main() {8    g := gop{"gop", 28}9    g.has()10}11import (12type gop interface {13    has()14}15type gop1 struct {16}17func (g gop1) has() {18    fmt.Println("gop1 has")19}20func main() {21    g = gop1{"gop1", 28}22    g.has()23}

1import (2func main() {3	g = gop{a: 10, b: 20}4	fmt.Println(g.has(10))5	fmt.Println(g.has(30))6}7import (8func main() {9	g = gop{a: 10, b: 20}10	fmt.Println(g.has(10))11	fmt.Println(g.has(30))12}13import (14func main() {15	g = gop{a: 10, b: 20}16	fmt.Println(g.has(10))17	fmt.Println(g.has(30))18}19import (20func main() {21	g = gop{a: 10, b: 20}22	fmt.Println(g.has(10))23	fmt.Println(g.has(30))24}25import (26func main() {27	g = gop{a: 10, b: 20}28	fmt.Println(g.has(10))29	fmt.Println(g.has(30))30}31import (32func main() {33	g = gop{a: 10, b: 20}34	fmt.Println(g.has(10))35	fmt.Println(g.has(30))36}37import (38func main() {39	g = gop{a: 10, b: 20}40	fmt.Println(g.has(10))41	fmt.Println(g.has(30))42}43import (44func main() {45	g = gop{a: 10, b: 20}46	fmt.Println(g

1import (2func main() {3	gop.RegisterGlobal("fmt", map[string]interface{}{4	})5	gop.RegisterGlobal("os", map[string]interface{}{6	})7	gop.RegisterGlobal("strings", map[string]interface{}{8	})

1import (2func main() {3    g = gop.New()4    g.Set(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)5    fmt.Println(g.Has(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))6    fmt.Println(g.Has(1, 2, 3, 4, 5, 6, 7, 8, 9, 11))7}8import (9func main() {10    g = gop.New()11    g.Set("hello", "world", "this", "is", "a", "gop", "class")12    fmt.Println(g.Has("hello", "world", "this", "is", "a", "gop", "class"))13    fmt.Println(g.Has("hello", "world", "this", "is", "a", "gop", "class", "example"))14}15import (16type Student struct {17}18func main() {19    g = gop.New()20    s1 := Student{"John", 1}21    s2 := Student{"Doe", 2}22    s3 := Student{"Alex", 3}23    s4 := Student{"Smith", 4}24    g.Set(s1, s2, s3, s4)25    fmt.Println(g.Has(s1, s2, s3, s4))26    fmt.Println(g.Has(s1, s2, s3, s4,

1import (2type gop struct {3}4func (g gop) has() {5	fmt.Println("Go has methods")6}7func main() {8	g := gop{name: "Golang"}9	g.has()10}11You can declare methods with pointer receivers. This means the receiver type has the literal syntax * T for some type T. (Also, T cannot itself be a pointer such as * int.)12type Vertex struct {13}14func (v *Vertex) Scale(f float64) {15}16Methods and pointer indirection (2)17Methods and pointer indirection (3)

1import "fmt"2func main() {3a = gop{"hello"}4a.has("hello")5a.has("world")6}7import "fmt"8func main() {9a = gop{"hello"}10a.has("hello")11a.has("world")12}13import "fmt"14func main() {15a = gop{"hello"}16a.has("hello")17a.has("world")18}19import "fmt"20func main() {21a = gop{"hello"}22a.has("hello")23a.has("world")24}25import "fmt"26func main() {27a = gop{"hello"}28a.has("hello")29a.has("world")30}31import "fmt"32func main() {33a = gop{"hello"}34a.has("hello")35a.has("world")36}37import "fmt"38func main() {39a = gop{"hello"}40a.has("hello")41a.has("world")42}43import "fmt"44func main() {45a = gop{"hello"}46a.has("hello")47a.has("world")48}49import "fmt"50func main() {51a = gop{"hello"}52a.has("hello")53a.has("world")54}55import "fmt"56func main() {57a = gop{"hello"}58a.has("hello")

1import (2func main() {3	fmt.Println("hello")4	gop.Has()5}6import (7type Gop struct {8}9func Has() {10	fmt.Println("has method")11}12import (13func main() {14	fmt.Println("hello")15	gop.Gop{}.Has()16}17In the above code, we have defined a method Has() in the file gop.go. We have used the method Has

1func main() {2    g := gop.New()3    g.Add(2)4    g.Add(3)5    g.Add(4)6    fmt.Println(g.Has(2))7    fmt.Println(g.Has(3))8    fmt.Println(g.Has(4))9}

1import (2func main() {3	fmt.Println("main")4	g1.Has()5}6import "fmt"7type Gop struct {8}9func (g Gop) Has() {10	fmt.Println("has")11}12import "fmt"13type Gop2 struct {14}15func (g Gop2) Has() {16	fmt.Println("has2")17}18import "fmt"19type Gop3 struct {20}21func (g Gop3) Has() {22	fmt.Println("has3")23}24import "fmt"25type Gop4 struct {26}27func (g Gop4) Has() {28	fmt.Println("has4")29}30import "fmt"31type Gop5 struct {32}33func (g Gop5) Has() {34	fmt.Println("has5")35}36import "fmt"37type Gop6 struct {38}39func (g Gop6) Has() {40	fmt.Println("has6")41}42import "fmt"43type Gop7 struct {44}45func (g Gop7) Has() {46	fmt.Println("has7")47}48import "fmt"49type Gop8 struct {50}51func (g Gop8) Has() {52	fmt.Println("has8")53}54import "fmt"55type Gop9 struct {56}57func (g Gop9) Has() {