1package funk 2 3import ( 4 "math/rand" 5) 6 7// InBools is an alias of ContainsBool, returns true if a bool is present in a iteratee. 8func InBools(s []bool, v bool) bool { 9 return ContainsBool(s, v) 10} 11 12// InInts is an alias of ContainsInt, returns true if an int is present in a iteratee. 13func InInts(s []int, v int) bool { 14 return ContainsInt(s, v) 15} 16 17// InInt32s is an alias of ContainsInt32, returns true if an int32 is present in a iteratee. 18func InInt32s(s []int32, v int32) bool { 19 return ContainsInt32(s, v) 20} 21 22// InInt64s is an alias of ContainsInt64, returns true if an int64 is present in a iteratee. 23func InInt64s(s []int64, v int64) bool { 24 return ContainsInt64(s, v) 25} 26 27// InUInts is an alias of ContainsUInt, returns true if an uint is present in a iteratee. 28func InUInts(s []uint, v uint) bool { 29 return ContainsUInt(s, v) 30} 31 32// InUInt32s is an alias of ContainsUInt32, returns true if an uint32 is present in a iteratee. 33func InUInt32s(s []uint32, v uint32) bool { 34 return ContainsUInt32(s, v) 35} 36 37// InUInt64s is an alias of ContainsUInt64, returns true if an uint64 is present in a iteratee. 38func InUInt64s(s []uint64, v uint64) bool { 39 return ContainsUInt64(s, v) 40} 41 42// InStrings is an alias of ContainsString, returns true if a string is present in a iteratee. 43func InStrings(s []string, v string) bool { 44 return ContainsString(s, v) 45} 46 47// InFloat32s is an alias of ContainsFloat32, returns true if a float32 is present in a iteratee. 48func InFloat32s(s []float32, v float32) bool { 49 return ContainsFloat32(s, v) 50} 51 52// InFloat64s is an alias of ContainsFloat64, returns true if a float64 is present in a iteratee. 53func InFloat64s(s []float64, v float64) bool { 54 return ContainsFloat64(s, v) 55} 56 57// FindFloat64 iterates over a collection of float64, returning an array of 58// all float64 elements predicate returns truthy for. 59func FindFloat64(s []float64, cb func(s float64) bool) (float64, bool) { 60 for _, i := range s { 61 result := cb(i) 62 63 if result { 64 return i, true 65 } 66 } 67 68 return 0.0, false 69} 70 71// FindFloat32 iterates over a collection of float32, returning the first 72// float32 element predicate returns truthy for. 73func FindFloat32(s []float32, cb func(s float32) bool) (float32, bool) { 74 for _, i := range s { 75 result := cb(i) 76 77 if result { 78 return i, true 79 } 80 } 81 82 return 0.0, false 83} 84 85// FindInt iterates over a collection of int, returning the first 86// int element predicate returns truthy for. 87func FindInt(s []int, cb func(s int) bool) (int, bool) { 88 for _, i := range s { 89 result := cb(i) 90 91 if result { 92 return i, true 93 } 94 } 95 96 return 0, false 97} 98 99// FindInt32 iterates over a collection of int32, returning the first 100// int32 element predicate returns truthy for. 101func FindInt32(s []int32, cb func(s int32) bool) (int32, bool) { 102 for _, i := range s { 103 result := cb(i) 104 105 if result { 106 return i, true 107 } 108 } 109 110 return 0, false 111} 112 113// FindInt64 iterates over a collection of int64, returning the first 114// int64 element predicate returns truthy for. 115func FindInt64(s []int64, cb func(s int64) bool) (int64, bool) { 116 for _, i := range s { 117 result := cb(i) 118 119 if result { 120 return i, true 121 } 122 } 123 124 return 0, false 125} 126 127// FindString iterates over a collection of string, returning the first 128// string element predicate returns truthy for. 129func FindString(s []string, cb func(s string) bool) (string, bool) { 130 for _, i := range s { 131 result := cb(i) 132 133 if result { 134 return i, true 135 } 136 } 137 138 return "", false 139} 140 141// FilterBool iterates over a collection of bool, returning an array of 142// all bool elements predicate returns truthy for. 143func FilterBool(s []bool, cb func(s bool) bool) []bool { 144 results := []bool{} 145 146 for _, i := range s { 147 result := cb(i) 148 149 if result { 150 results = append(results, i) 151 } 152 } 153 154 return results 155} 156 157// FilterFloat64 iterates over a collection of float64, returning an array of 158// all float64 elements predicate returns truthy for. 159func FilterFloat64(s []float64, cb func(s float64) bool) []float64 { 160 results := []float64{} 161 162 for _, i := range s { 163 result := cb(i) 164 165 if result { 166 results = append(results, i) 167 } 168 } 169 170 return results 171} 172 173// FilterFloat32 iterates over a collection of float32, returning an array of 174// all float32 elements predicate returns truthy for. 175func FilterFloat32(s []float32, cb func(s float32) bool) []float32 { 176 results := []float32{} 177 178 for _, i := range s { 179 result := cb(i) 180 181 if result { 182 results = append(results, i) 183 } 184 } 185 186 return results 187} 188 189// FilterInt iterates over a collection of int, returning an array of 190// all int elements predicate returns truthy for. 191func FilterInt(s []int, cb func(s int) bool) []int { 192 results := []int{} 193 194 for _, i := range s { 195 result := cb(i) 196 197 if result { 198 results = append(results, i) 199 } 200 } 201 202 return results 203} 204 205// FilterInt32 iterates over a collection of int32, returning an array of 206// all int32 elements predicate returns truthy for. 207func FilterInt32(s []int32, cb func(s int32) bool) []int32 { 208 results := []int32{} 209 210 for _, i := range s { 211 result := cb(i) 212 213 if result { 214 results = append(results, i) 215 } 216 } 217 218 return results 219} 220 221// FilterInt64 iterates over a collection of int64, returning an array of 222// all int64 elements predicate returns truthy for. 223func FilterInt64(s []int64, cb func(s int64) bool) []int64 { 224 results := []int64{} 225 226 for _, i := range s { 227 result := cb(i) 228 229 if result { 230 results = append(results, i) 231 } 232 } 233 234 return results 235} 236 237// FilterUInt iterates over a collection of uint, returning an array of 238// all uint elements predicate returns truthy for. 239func FilterUInt(s []uint, cb func(s uint) bool) []uint { 240 results := []uint{} 241 242 for _, i := range s { 243 result := cb(i) 244 245 if result { 246 results = append(results, i) 247 } 248 } 249 250 return results 251} 252 253// FilterUInt32 iterates over a collection of uint32, returning an array of 254// all uint32 elements predicate returns truthy for. 255func FilterUInt32(s []uint32, cb func(s uint32) bool) []uint32 { 256 results := []uint32{} 257 258 for _, i := range s { 259 result := cb(i) 260 261 if result { 262 results = append(results, i) 263 } 264 } 265 266 return results 267} 268 269// FilterUInt64 iterates over a collection of uint64, returning an array of 270// all uint64 elements predicate returns truthy for. 271func FilterUInt64(s []uint64, cb func(s uint64) bool) []uint64 { 272 results := []uint64{} 273 274 for _, i := range s { 275 result := cb(i) 276 277 if result { 278 results = append(results, i) 279 } 280 } 281 282 return results 283} 284 285// FilterString iterates over a collection of string, returning an array of 286// all string elements predicate returns truthy for. 287func FilterString(s []string, cb func(s string) bool) []string { 288 results := []string{} 289 290 for _, i := range s { 291 result := cb(i) 292 293 if result { 294 results = append(results, i) 295 } 296 } 297 298 return results 299} 300 301// ContainsBool returns true if a boolean is present in a iteratee. 302func ContainsBool(s []bool, v bool) bool { 303 for _, vv := range s { 304 if vv == v { 305 return true 306 } 307 } 308 return false 309} 310 311// ContainsInt returns true if an int is present in a iteratee. 312func ContainsInt(s []int, v int) bool { 313 for _, vv := range s { 314 if vv == v { 315 return true 316 } 317 } 318 return false 319} 320 321// ContainsInt32 returns true if an int32 is present in a iteratee. 322func ContainsInt32(s []int32, v int32) bool { 323 for _, vv := range s { 324 if vv == v { 325 return true 326 } 327 } 328 return false 329} 330 331// ContainsInt64 returns true if an int64 is present in a iteratee. 332func ContainsInt64(s []int64, v int64) bool { 333 for _, vv := range s { 334 if vv == v { 335 return true 336 } 337 } 338 return false 339} 340 341// ContainsUInt returns true if an uint is present in a iteratee. 342func ContainsUInt(s []uint, v uint) bool { 343 for _, vv := range s { 344 if vv == v { 345 return true 346 } 347 } 348 return false 349} 350 351// ContainsUInt32 returns true if an uint32 is present in a iteratee. 352func ContainsUInt32(s []uint32, v uint32) bool { 353 for _, vv := range s { 354 if vv == v { 355 return true 356 } 357 } 358 return false 359} 360 361// ContainsUInt64 returns true if an uint64 is present in a iteratee. 362func ContainsUInt64(s []uint64, v uint64) bool { 363 for _, vv := range s { 364 if vv == v { 365 return true 366 } 367 } 368 return false 369} 370 371// ContainsString returns true if a string is present in a iteratee. 372func ContainsString(s []string, v string) bool { 373 for _, vv := range s { 374 if vv == v { 375 return true 376 } 377 } 378 return false 379} 380 381// ContainsFloat32 returns true if a float32 is present in a iteratee. 382func ContainsFloat32(s []float32, v float32) bool { 383 for _, vv := range s { 384 if vv == v { 385 return true 386 } 387 } 388 return false 389} 390 391// ContainsFloat64 returns true if a float64 is present in a iteratee. 392func ContainsFloat64(s []float64, v float64) bool { 393 for _, vv := range s { 394 if vv == v { 395 return true 396 } 397 } 398 return false 399} 400 401// SumInt32 sums a int32 iteratee and returns the sum of all elements 402func SumInt32(s []int32) (sum int32) { 403 for _, v := range s { 404 sum += v 405 } 406 return 407} 408 409// SumInt64 sums a int64 iteratee and returns the sum of all elements 410func SumInt64(s []int64) (sum int64) { 411 for _, v := range s { 412 sum += v 413 } 414 return 415} 416 417// SumInt sums a int iteratee and returns the sum of all elements 418func SumInt(s []int) (sum int) { 419 for _, v := range s { 420 sum += v 421 } 422 return 423} 424 425// SumUInt32 sums a uint32 iteratee and returns the sum of all elements 426func SumUInt32(s []uint32) (sum uint32) { 427 for _, v := range s { 428 sum += v 429 } 430 return 431} 432 433// SumUInt64 sums a uint64 iteratee and returns the sum of all elements 434func SumUInt64(s []uint64) (sum uint64) { 435 for _, v := range s { 436 sum += v 437 } 438 return 439} 440 441// SumUInt sums a uint iteratee and returns the sum of all elements 442func SumUInt(s []uint) (sum uint) { 443 for _, v := range s { 444 sum += v 445 } 446 return 447} 448 449// SumFloat64 sums a float64 iteratee and returns the sum of all elements 450func SumFloat64(s []float64) (sum float64) { 451 for _, v := range s { 452 sum += v 453 } 454 return 455} 456 457// SumFloat32 sums a float32 iteratee and returns the sum of all elements 458func SumFloat32(s []float32) (sum float32) { 459 for _, v := range s { 460 sum += v 461 } 462 return 463} 464 465// ReverseBools reverses an array of bool 466func ReverseBools(s []bool) []bool { 467 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 468 s[i], s[j] = s[j], s[i] 469 } 470 return s 471} 472 473// ReverseStrings reverses an array of string 474func ReverseStrings(s []string) []string { 475 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 476 s[i], s[j] = s[j], s[i] 477 } 478 return s 479} 480 481// ReverseInt reverses an array of int 482func ReverseInt(s []int) []int { 483 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 484 s[i], s[j] = s[j], s[i] 485 } 486 return s 487} 488 489// ReverseInt32 reverses an array of int32 490func ReverseInt32(s []int32) []int32 { 491 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 492 s[i], s[j] = s[j], s[i] 493 } 494 return s 495} 496 497// ReverseInt64 reverses an array of int64 498func ReverseInt64(s []int64) []int64 { 499 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 500 s[i], s[j] = s[j], s[i] 501 } 502 return s 503} 504 505// ReverseUInt reverses an array of int 506func ReverseUInt(s []uint) []uint { 507 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 508 s[i], s[j] = s[j], s[i] 509 } 510 return s 511} 512 513// ReverseUInt32 reverses an array of uint32 514func ReverseUInt32(s []uint32) []uint32 { 515 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 516 s[i], s[j] = s[j], s[i] 517 } 518 return s 519} 520 521// ReverseUInt64 reverses an array of uint64 522func ReverseUInt64(s []uint64) []uint64 { 523 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 524 s[i], s[j] = s[j], s[i] 525 } 526 return s 527} 528 529// ReverseFloat64 reverses an array of float64 530func ReverseFloat64(s []float64) []float64 { 531 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 532 s[i], s[j] = s[j], s[i] 533 } 534 return s 535} 536 537// ReverseFloat32 reverses an array of float32 538func ReverseFloat32(s []float32) []float32 { 539 for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 { 540 s[i], s[j] = s[j], s[i] 541 } 542 return s 543} 544 545// ReverseString reverses a string 546func ReverseString(s string) string { 547 r := []rune(s) 548 for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { 549 r[i], r[j] = r[j], r[i] 550 } 551 return string(r) 552} 553 554func indexOf(n int, f func(int) bool) int { 555 for i := 0; i < n; i++ { 556 if f(i) { 557 return i 558 } 559 } 560 return -1 561} 562 563// IndexOfBool gets the index at which the first occurrence of a bool value is found in array or return -1 564// if the value cannot be found 565func IndexOfBool(a []bool, x bool) int { 566 return indexOf(len(a), func(i int) bool { return a[i] == x }) 567} 568 569// IndexOfInt gets the index at which the first occurrence of an int value is found in array or return -1 570// if the value cannot be found 571func IndexOfInt(a []int, x int) int { 572 return indexOf(len(a), func(i int) bool { return a[i] == x }) 573} 574 575// IndexOfInt32 gets the index at which the first occurrence of an int32 value is found in array or return -1 576// if the value cannot be found 577func IndexOfInt32(a []int32, x int32) int { 578 return indexOf(len(a), func(i int) bool { return a[i] == x }) 579} 580 581// IndexOfInt64 gets the index at which the first occurrence of an int64 value is found in array or return -1 582// if the value cannot be found 583func IndexOfInt64(a []int64, x int64) int { 584 return indexOf(len(a), func(i int) bool { return a[i] == x }) 585} 586 587// IndexOfUInt gets the index at which the first occurrence of an uint value is found in array or return -1 588// if the value cannot be found 589func IndexOfUInt(a []uint, x uint) int { 590 return indexOf(len(a), func(i int) bool { return a[i] == x }) 591} 592 593// IndexOfUInt32 gets the index at which the first occurrence of an uint32 value is found in array or return -1 594// if the value cannot be found 595func IndexOfUInt32(a []uint32, x uint32) int { 596 return indexOf(len(a), func(i int) bool { return a[i] == x }) 597} 598 599// IndexOfUInt64 gets the index at which the first occurrence of an uint64 value is found in array or return -1 600// if the value cannot be found 601func IndexOfUInt64(a []uint64, x uint64) int { 602 return indexOf(len(a), func(i int) bool { return a[i] == x }) 603} 604 605// IndexOfFloat64 gets the index at which the first occurrence of an float64 value is found in array or return -1 606// if the value cannot be found 607func IndexOfFloat64(a []float64, x float64) int { 608 return indexOf(len(a), func(i int) bool { return a[i] == x }) 609} 610 611// IndexOfString gets the index at which the first occurrence of a string value is found in array or return -1 612// if the value cannot be found 613func IndexOfString(a []string, x string) int { 614 return indexOf(len(a), func(i int) bool { return a[i] == x }) 615} 616 617func lastIndexOf(n int, f func(int) bool) int { 618 for i := n - 1; i >= 0; i-- { 619 if f(i) { 620 return i 621 } 622 } 623 return -1 624} 625 626// LastIndexOfBool gets the index at which the first occurrence of a bool value is found in array or return -1 627// if the value cannot be found 628func LastIndexOfBool(a []bool, x bool) int { 629 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 630} 631 632// LastIndexOfInt gets the index at which the first occurrence of an int value is found in array or return -1 633// if the value cannot be found 634func LastIndexOfInt(a []int, x int) int { 635 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 636} 637 638// LastIndexOfInt32 gets the index at which the first occurrence of an int32 value is found in array or return -1 639// if the value cannot be found 640func LastIndexOfInt32(a []int32, x int32) int { 641 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 642} 643 644// LastIndexOfInt64 gets the index at which the first occurrence of an int64 value is found in array or return -1 645// if the value cannot be found 646func LastIndexOfInt64(a []int64, x int64) int { 647 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 648} 649 650// LastIndexOfUInt gets the index at which the first occurrence of an uint value is found in array or return -1 651// if the value cannot be found 652func LastIndexOfUInt(a []uint, x uint) int { 653 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 654} 655 656// LastIndexOfUInt32 gets the index at which the first occurrence of an uint32 value is found in array or return -1 657// if the value cannot be found 658func LastIndexOfUInt32(a []uint32, x uint32) int { 659 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 660} 661 662// LastIndexOfUInt64 gets the index at which the first occurrence of an uint64 value is found in array or return -1 663// if the value cannot be found 664func LastIndexOfUInt64(a []uint64, x uint64) int { 665 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 666} 667 668// LastIndexOfFloat64 gets the index at which the first occurrence of an float64 value is found in array or return -1 669// if the value cannot be found 670func LastIndexOfFloat64(a []float64, x float64) int { 671 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 672} 673 674// LastIndexOfFloat32 gets the index at which the first occurrence of an float32 value is found in array or return -1 675// if the value cannot be found 676func LastIndexOfFloat32(a []float32, x float32) int { 677 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 678} 679 680// LastIndexOfString gets the index at which the first occurrence of a string value is found in array or return -1 681// if the value cannot be found 682func LastIndexOfString(a []string, x string) int { 683 return lastIndexOf(len(a), func(i int) bool { return a[i] == x }) 684} 685 686// UniqBool creates an array of bool with unique values. 687func UniqBool(a []bool) []bool { 688 results := []bool{} 689 for _, value := range a { 690 // If results is not empty, there is at most 1 value in it 691 if len(results) == 0 || results[0] != value { 692 results = append(results, value) 693 } 694 // At most 2 unique values 695 if len(results) == 2 { 696 break 697 } 698 } 699 return results 700} 701 702// UniqInt32 creates an array of int32 with unique values. 703func UniqInt32(a []int32) []int32 { 704 var ( 705 length = len(a) 706 seen = make(map[int32]struct{}, length) 707 j = 0 708 results = make([]int32, 0) 709 ) 710 711 for i := 0; i < length; i++ { 712 v := a[i] 713 714 if _, ok := seen[v]; ok { 715 continue 716 } 717 718 seen[v] = struct{}{} 719 results = append(results, v) 720 j++ 721 } 722 723 return results 724} 725 726// UniqInt64 creates an array of int64 with unique values. 727func UniqInt64(a []int64) []int64 { 728 var ( 729 length = len(a) 730 seen = make(map[int64]struct{}, length) 731 results = make([]int64, 0) 732 j = 0 733 ) 734 735 for i := 0; i < length; i++ { 736 v := a[i] 737 738 if _, ok := seen[v]; ok { 739 continue 740 } 741 742 seen[v] = struct{}{} 743 results = append(results, v) 744 j++ 745 } 746 747 return results 748} 749 750// UniqInt creates an array of int with unique values. 751func UniqInt(a []int) []int { 752 var ( 753 length = len(a) 754 seen = make(map[int]struct{}, length) 755 results = make([]int, 0) 756 j = 0 757 ) 758 759 for i := 0; i < length; i++ { 760 v := a[i] 761 762 if _, ok := seen[v]; ok { 763 continue 764 } 765 766 seen[v] = struct{}{} 767 results = append(results, v) 768 j++ 769 } 770 771 return results 772} 773 774// UniqUInt32 creates an array of uint32 with unique values. 775func UniqUInt32(a []uint32) []uint32 { 776 var ( 777 length = len(a) 778 seen = make(map[uint32]struct{}, length) 779 j = 0 780 results = make([]uint32, 0) 781 ) 782 783 for i := 0; i < length; i++ { 784 v := a[i] 785 786 if _, ok := seen[v]; ok { 787 continue 788 } 789 790 seen[v] = struct{}{} 791 results = append(results, v) 792 j++ 793 } 794 795 return results 796} 797 798// UniqUInt64 creates an array of uint64 with unique values. 799func UniqUInt64(a []uint64) []uint64 { 800 var ( 801 length = len(a) 802 seen = make(map[uint64]struct{}, length) 803 j = 0 804 results = make([]uint64, 0) 805 ) 806 807 for i := 0; i < length; i++ { 808 v := a[i] 809 810 if _, ok := seen[v]; ok { 811 continue 812 } 813 814 seen[v] = struct{}{} 815 results = append(results, v) 816 j++ 817 } 818 819 return results 820} 821 822// UniqUInt creates an array of uint with unique values. 823func UniqUInt(a []uint) []uint { 824 var ( 825 length = len(a) 826 seen = make(map[uint]struct{}, length) 827 j = 0 828 results = make([]uint, 0) 829 ) 830 831 for i := 0; i < length; i++ { 832 v := a[i] 833 834 if _, ok := seen[v]; ok { 835 continue 836 } 837 838 seen[v] = struct{}{} 839 results = append(results, v) 840 j++ 841 } 842 843 return results 844} 845 846// UniqString creates an array of string with unique values. 847func UniqString(a []string) []string { 848 var ( 849 length = len(a) 850 seen = make(map[string]struct{}, length) 851 j = 0 852 results = make([]string, 0) 853 ) 854 855 for i := 0; i < length; i++ { 856 v := a[i] 857 858 if _, ok := seen[v]; ok { 859 continue 860 } 861 862 seen[v] = struct{}{} 863 results = append(results, v) 864 j++ 865 } 866 867 return results 868} 869 870// UniqFloat64 creates an array of float64 with unique values. 871func UniqFloat64(a []float64) []float64 { 872 var ( 873 length = len(a) 874 seen = make(map[float64]struct{}, length) 875 j = 0 876 results = make([]float64, 0) 877 ) 878 879 for i := 0; i < length; i++ { 880 v := a[i] 881 882 if _, ok := seen[v]; ok { 883 continue 884 } 885 886 seen[v] = struct{}{} 887 results = append(results, v) 888 j++ 889 } 890 891 return results 892} 893 894// UniqFloat32 creates an array of float32 with unique values. 895func UniqFloat32(a []float32) []float32 { 896 var ( 897 length = len(a) 898 seen = make(map[float32]struct{}, length) 899 j = 0 900 results = make([]float32, 0) 901 ) 902 903 for i := 0; i < length; i++ { 904 v := a[i] 905 906 if _, ok := seen[v]; ok { 907 continue 908 } 909 910 seen[v] = struct{}{} 911 results = append(results, v) 912 j++ 913 } 914 915 return results 916} 917 918// ShuffleBool creates an array of bool shuffled values using Fisher–Yates algorithm 919func ShuffleBool(a []bool) []bool { 920 for i := range a { 921 j := rand.Intn(i + 1) 922 a[i], a[j] = a[j], a[i] 923 } 924 925 return a 926} 927 928// ShuffleInt creates an array of int shuffled values using Fisher–Yates algorithm 929func ShuffleInt(a []int) []int { 930 for i := range a { 931 j := rand.Intn(i + 1) 932 a[i], a[j] = a[j], a[i] 933 } 934 935 return a 936} 937 938// ShuffleInt32 creates an array of int32 shuffled values using Fisher–Yates algorithm 939func ShuffleInt32(a []int32) []int32 { 940 for i := range a { 941 j := rand.Intn(i + 1) 942 a[i], a[j] = a[j], a[i] 943 } 944 945 return a 946} 947 948// ShuffleInt64 creates an array of int64 shuffled values using Fisher–Yates algorithm 949func ShuffleInt64(a []int64) []int64 { 950 for i := range a { 951 j := rand.Intn(i + 1) 952 a[i], a[j] = a[j], a[i] 953 } 954 955 return a 956} 957 958// ShuffleUInt creates an array of int shuffled values using Fisher–Yates algorithm 959func ShuffleUInt(a []uint) []uint { 960 for i := range a { 961 j := rand.Intn(i + 1) 962 a[i], a[j] = a[j], a[i] 963 } 964 965 return a 966} 967 968// ShuffleUInt32 creates an array of uint32 shuffled values using Fisher–Yates algorithm 969func ShuffleUInt32(a []uint32) []uint32 { 970 for i := range a { 971 j := rand.Intn(i + 1) 972 a[i], a[j] = a[j], a[i] 973 } 974 975 return a 976} 977 978// ShuffleUInt64 creates an array of uint64 shuffled values using Fisher–Yates algorithm 979func ShuffleUInt64(a []uint64) []uint64 { 980 for i := range a { 981 j := rand.Intn(i + 1) 982 a[i], a[j] = a[j], a[i] 983 } 984 985 return a 986} 987 988// ShuffleString creates an array of string shuffled values using Fisher–Yates algorithm 989func ShuffleString(a []string) []string { 990 for i := range a { 991 j := rand.Intn(i + 1) 992 a[i], a[j] = a[j], a[i] 993 } 994 995 return a 996} 997 998// ShuffleFloat32 creates an array of float32 shuffled values using Fisher–Yates algorithm 999func ShuffleFloat32(a []float32) []float32 { 1000 for i := range a { 1001 j := rand.Intn(i + 1) 1002 a[i], a[j] = a[j], a[i] 1003 } 1004 1005 return a 1006} 1007 1008// ShuffleFloat64 creates an array of float64 shuffled values using Fisher–Yates algorithm 1009func ShuffleFloat64(a []float64) []float64 { 1010 for i := range a { 1011 j := rand.Intn(i + 1) 1012 a[i], a[j] = a[j], a[i] 1013 } 1014 1015 return a 1016} 1017 1018// DropBool creates a slice with `n` bools dropped from the beginning. 1019func DropBool(s []bool, n int) []bool { 1020 return s[n:] 1021} 1022 1023// DropString creates a slice with `n` strings dropped from the beginning. 1024func DropString(s []string, n int) []string { 1025 return s[n:] 1026} 1027 1028// DropInt creates a slice with `n` ints dropped from the beginning. 1029func DropInt(s []int, n int) []int { 1030 return s[n:] 1031} 1032 1033// DropInt32 creates a slice with `n` int32s dropped from the beginning. 1034func DropInt32(s []int32, n int) []int32 { 1035 return s[n:] 1036} 1037 1038// DropInt64 creates a slice with `n` int64s dropped from the beginning. 1039func DropInt64(s []int64, n int) []int64 { 1040 return s[n:] 1041} 1042 1043// DropUInt creates a slice with `n` ints dropped from the beginning. 1044func DropUInt(s []uint, n uint) []uint { 1045 return s[n:] 1046} 1047 1048// DropUInt32 creates a slice with `n` int32s dropped from the beginning. 1049func DropUInt32(s []uint32, n int) []uint32 { 1050 return s[n:] 1051} 1052 1053// DropUInt64 creates a slice with `n` int64s dropped from the beginning. 1054func DropUInt64(s []uint64, n int) []uint64 { 1055 return s[n:] 1056} 1057 1058// DropFloat32 creates a slice with `n` float32s dropped from the beginning. 1059func DropFloat32(s []float32, n int) []float32 { 1060 return s[n:] 1061} 1062 1063// DropFloat64 creates a slice with `n` float64s dropped from the beginning. 1064func DropFloat64(s []float64, n int) []float64 { 1065 return s[n:] 1066} 1067 1068// ChunkStrings creates an array of strings split into groups with the length of size. 1069// If array can't be split evenly, the final chunk will be 1070// the remaining element. 1071func ChunkStrings(arr []string, size int) [][]string { 1072 var results [][]string 1073 1074 for i := 0; i < len(arr); i += size { 1075 end := i + size 1076 1077 if end > len(arr) { 1078 end = len(arr) 1079 } 1080 1081 results = append(results, arr[i:end]) 1082 } 1083 1084 return results 1085} 1086 1087// ChunkInts creates an array of ints split into groups with the length of size. 1088// If array can't be split evenly, the final chunk will be 1089// the remaining element. 1090func ChunkInts(arr []int, size int) [][]int { 1091 var results [][]int 1092 1093 for i := 0; i < len(arr); i += size { 1094 end := i + size 1095 1096 if end > len(arr) { 1097 end = len(arr) 1098 } 1099 1100 results = append(results, arr[i:end]) 1101 } 1102 1103 return results 1104} 1105 1106// ChunkInt32s creates an array of int32s split into groups with the length of size. 1107// If array can't be split evenly, the final chunk will be 1108// the remaining element. 1109func ChunkInt32s(arr []int32, size int) [][]int32 { 1110 var results [][]int32 1111 1112 for i := 0; i < len(arr); i += size { 1113 end := i + size 1114 1115 if end > len(arr) { 1116 end = len(arr) 1117 } 1118 1119 results = append(results, arr[i:end]) 1120 } 1121 1122 return results 1123} 1124 1125// ChunkInt64s creates an array of int64s split into groups with the length of size. 1126// If array can't be split evenly, the final chunk will be 1127// the remaining element. 1128func ChunkInt64s(arr []int64, size int) [][]int64 { 1129 var results [][]int64 1130 1131 for i := 0; i < len(arr); i += size { 1132 end := i + size 1133 1134 if end > len(arr) { 1135 end = len(arr) 1136 } 1137 1138 results = append(results, arr[i:end]) 1139 } 1140 1141 return results 1142} 1143 1144// ChunkFloat64s creates an array of float64s split into groups with the length of size. 1145// If array can't be split evenly, the final chunk will be 1146// the remaining element. 1147func ChunkFloat64s(arr []float64, size int) [][]float64 { 1148 var results [][]float64 1149 1150 for i := 0; i < len(arr); i += size { 1151 end := i + size 1152 1153 if end > len(arr) { 1154 end = len(arr) 1155 } 1156 1157 results = append(results, arr[i:end]) 1158 } 1159 1160 return results 1161} 1162