gorgonia.org/tensor@v0.9.24/internal/execution/eng_map.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package execution
     4  
     5  import (
     6  	"reflect"
     7  	"unsafe"
     8  
     9  	"github.com/pkg/errors"
    10  	"gorgonia.org/tensor/internal/storage"
    11  )
    12  
    13  func (e E) Map(t reflect.Type, fn interface{}, a *storage.Header, incr bool) (err error) {
    14  	as := isScalar(a, t)
    15  	switch t {
    16  	case Bool:
    17  		var f0 func(bool) bool
    18  		var f1 func(bool) (bool, error)
    19  
    20  		switch f := fn.(type) {
    21  		case func(bool) bool:
    22  			f0 = f
    23  		case func(bool) (bool, error):
    24  			f1 = f
    25  		default:
    26  			return errors.Errorf("Cannot map fn of %T to array", fn)
    27  		}
    28  
    29  		at := a.Bools()
    30  		if incr {
    31  			return errors.Errorf("Cannot perform increment on t of %v", t)
    32  		}
    33  		switch {
    34  		case as && f0 != nil:
    35  			at[0] = f0(at[0])
    36  		case as && f0 == nil:
    37  			at[0], err = f1(at[0])
    38  		case !as && f0 == nil:
    39  			err = MapErrB(f1, at)
    40  		default:
    41  			MapB(f0, at)
    42  		}
    43  	case Int:
    44  		var f0 func(int) int
    45  		var f1 func(int) (int, error)
    46  
    47  		switch f := fn.(type) {
    48  		case func(int) int:
    49  			f0 = f
    50  		case func(int) (int, error):
    51  			f1 = f
    52  		default:
    53  			return errors.Errorf("Cannot map fn of %T to array", fn)
    54  		}
    55  
    56  		at := a.Ints()
    57  		switch {
    58  		case as && incr && f0 != nil:
    59  			at[0] += f0(at[0])
    60  		case as && incr && f0 == nil:
    61  			var tmp int
    62  			if tmp, err = f1(at[0]); err != nil {
    63  				return
    64  			}
    65  			at[0] += tmp
    66  		case as && !incr && f0 != nil:
    67  			at[0] = f0(at[0])
    68  		case as && !incr && f0 == nil:
    69  			at[0], err = f1(at[0])
    70  		case !as && incr && f0 != nil:
    71  			MapIncrI(f0, at)
    72  		case !as && incr && f0 == nil:
    73  			err = MapIncrErrI(f1, at)
    74  		case !as && !incr && f0 == nil:
    75  			err = MapErrI(f1, at)
    76  		default:
    77  			MapI(f0, at)
    78  		}
    79  	case Int8:
    80  		var f0 func(int8) int8
    81  		var f1 func(int8) (int8, error)
    82  
    83  		switch f := fn.(type) {
    84  		case func(int8) int8:
    85  			f0 = f
    86  		case func(int8) (int8, error):
    87  			f1 = f
    88  		default:
    89  			return errors.Errorf("Cannot map fn of %T to array", fn)
    90  		}
    91  
    92  		at := a.Int8s()
    93  		switch {
    94  		case as && incr && f0 != nil:
    95  			at[0] += f0(at[0])
    96  		case as && incr && f0 == nil:
    97  			var tmp int8
    98  			if tmp, err = f1(at[0]); err != nil {
    99  				return
   100  			}
   101  			at[0] += tmp
   102  		case as && !incr && f0 != nil:
   103  			at[0] = f0(at[0])
   104  		case as && !incr && f0 == nil:
   105  			at[0], err = f1(at[0])
   106  		case !as && incr && f0 != nil:
   107  			MapIncrI8(f0, at)
   108  		case !as && incr && f0 == nil:
   109  			err = MapIncrErrI8(f1, at)
   110  		case !as && !incr && f0 == nil:
   111  			err = MapErrI8(f1, at)
   112  		default:
   113  			MapI8(f0, at)
   114  		}
   115  	case Int16:
   116  		var f0 func(int16) int16
   117  		var f1 func(int16) (int16, error)
   118  
   119  		switch f := fn.(type) {
   120  		case func(int16) int16:
   121  			f0 = f
   122  		case func(int16) (int16, error):
   123  			f1 = f
   124  		default:
   125  			return errors.Errorf("Cannot map fn of %T to array", fn)
   126  		}
   127  
   128  		at := a.Int16s()
   129  		switch {
   130  		case as && incr && f0 != nil:
   131  			at[0] += f0(at[0])
   132  		case as && incr && f0 == nil:
   133  			var tmp int16
   134  			if tmp, err = f1(at[0]); err != nil {
   135  				return
   136  			}
   137  			at[0] += tmp
   138  		case as && !incr && f0 != nil:
   139  			at[0] = f0(at[0])
   140  		case as && !incr && f0 == nil:
   141  			at[0], err = f1(at[0])
   142  		case !as && incr && f0 != nil:
   143  			MapIncrI16(f0, at)
   144  		case !as && incr && f0 == nil:
   145  			err = MapIncrErrI16(f1, at)
   146  		case !as && !incr && f0 == nil:
   147  			err = MapErrI16(f1, at)
   148  		default:
   149  			MapI16(f0, at)
   150  		}
   151  	case Int32:
   152  		var f0 func(int32) int32
   153  		var f1 func(int32) (int32, error)
   154  
   155  		switch f := fn.(type) {
   156  		case func(int32) int32:
   157  			f0 = f
   158  		case func(int32) (int32, error):
   159  			f1 = f
   160  		default:
   161  			return errors.Errorf("Cannot map fn of %T to array", fn)
   162  		}
   163  
   164  		at := a.Int32s()
   165  		switch {
   166  		case as && incr && f0 != nil:
   167  			at[0] += f0(at[0])
   168  		case as && incr && f0 == nil:
   169  			var tmp int32
   170  			if tmp, err = f1(at[0]); err != nil {
   171  				return
   172  			}
   173  			at[0] += tmp
   174  		case as && !incr && f0 != nil:
   175  			at[0] = f0(at[0])
   176  		case as && !incr && f0 == nil:
   177  			at[0], err = f1(at[0])
   178  		case !as && incr && f0 != nil:
   179  			MapIncrI32(f0, at)
   180  		case !as && incr && f0 == nil:
   181  			err = MapIncrErrI32(f1, at)
   182  		case !as && !incr && f0 == nil:
   183  			err = MapErrI32(f1, at)
   184  		default:
   185  			MapI32(f0, at)
   186  		}
   187  	case Int64:
   188  		var f0 func(int64) int64
   189  		var f1 func(int64) (int64, error)
   190  
   191  		switch f := fn.(type) {
   192  		case func(int64) int64:
   193  			f0 = f
   194  		case func(int64) (int64, error):
   195  			f1 = f
   196  		default:
   197  			return errors.Errorf("Cannot map fn of %T to array", fn)
   198  		}
   199  
   200  		at := a.Int64s()
   201  		switch {
   202  		case as && incr && f0 != nil:
   203  			at[0] += f0(at[0])
   204  		case as && incr && f0 == nil:
   205  			var tmp int64
   206  			if tmp, err = f1(at[0]); err != nil {
   207  				return
   208  			}
   209  			at[0] += tmp
   210  		case as && !incr && f0 != nil:
   211  			at[0] = f0(at[0])
   212  		case as && !incr && f0 == nil:
   213  			at[0], err = f1(at[0])
   214  		case !as && incr && f0 != nil:
   215  			MapIncrI64(f0, at)
   216  		case !as && incr && f0 == nil:
   217  			err = MapIncrErrI64(f1, at)
   218  		case !as && !incr && f0 == nil:
   219  			err = MapErrI64(f1, at)
   220  		default:
   221  			MapI64(f0, at)
   222  		}
   223  	case Uint:
   224  		var f0 func(uint) uint
   225  		var f1 func(uint) (uint, error)
   226  
   227  		switch f := fn.(type) {
   228  		case func(uint) uint:
   229  			f0 = f
   230  		case func(uint) (uint, error):
   231  			f1 = f
   232  		default:
   233  			return errors.Errorf("Cannot map fn of %T to array", fn)
   234  		}
   235  
   236  		at := a.Uints()
   237  		switch {
   238  		case as && incr && f0 != nil:
   239  			at[0] += f0(at[0])
   240  		case as && incr && f0 == nil:
   241  			var tmp uint
   242  			if tmp, err = f1(at[0]); err != nil {
   243  				return
   244  			}
   245  			at[0] += tmp
   246  		case as && !incr && f0 != nil:
   247  			at[0] = f0(at[0])
   248  		case as && !incr && f0 == nil:
   249  			at[0], err = f1(at[0])
   250  		case !as && incr && f0 != nil:
   251  			MapIncrU(f0, at)
   252  		case !as && incr && f0 == nil:
   253  			err = MapIncrErrU(f1, at)
   254  		case !as && !incr && f0 == nil:
   255  			err = MapErrU(f1, at)
   256  		default:
   257  			MapU(f0, at)
   258  		}
   259  	case Uint8:
   260  		var f0 func(uint8) uint8
   261  		var f1 func(uint8) (uint8, error)
   262  
   263  		switch f := fn.(type) {
   264  		case func(uint8) uint8:
   265  			f0 = f
   266  		case func(uint8) (uint8, error):
   267  			f1 = f
   268  		default:
   269  			return errors.Errorf("Cannot map fn of %T to array", fn)
   270  		}
   271  
   272  		at := a.Uint8s()
   273  		switch {
   274  		case as && incr && f0 != nil:
   275  			at[0] += f0(at[0])
   276  		case as && incr && f0 == nil:
   277  			var tmp uint8
   278  			if tmp, err = f1(at[0]); err != nil {
   279  				return
   280  			}
   281  			at[0] += tmp
   282  		case as && !incr && f0 != nil:
   283  			at[0] = f0(at[0])
   284  		case as && !incr && f0 == nil:
   285  			at[0], err = f1(at[0])
   286  		case !as && incr && f0 != nil:
   287  			MapIncrU8(f0, at)
   288  		case !as && incr && f0 == nil:
   289  			err = MapIncrErrU8(f1, at)
   290  		case !as && !incr && f0 == nil:
   291  			err = MapErrU8(f1, at)
   292  		default:
   293  			MapU8(f0, at)
   294  		}
   295  	case Uint16:
   296  		var f0 func(uint16) uint16
   297  		var f1 func(uint16) (uint16, error)
   298  
   299  		switch f := fn.(type) {
   300  		case func(uint16) uint16:
   301  			f0 = f
   302  		case func(uint16) (uint16, error):
   303  			f1 = f
   304  		default:
   305  			return errors.Errorf("Cannot map fn of %T to array", fn)
   306  		}
   307  
   308  		at := a.Uint16s()
   309  		switch {
   310  		case as && incr && f0 != nil:
   311  			at[0] += f0(at[0])
   312  		case as && incr && f0 == nil:
   313  			var tmp uint16
   314  			if tmp, err = f1(at[0]); err != nil {
   315  				return
   316  			}
   317  			at[0] += tmp
   318  		case as && !incr && f0 != nil:
   319  			at[0] = f0(at[0])
   320  		case as && !incr && f0 == nil:
   321  			at[0], err = f1(at[0])
   322  		case !as && incr && f0 != nil:
   323  			MapIncrU16(f0, at)
   324  		case !as && incr && f0 == nil:
   325  			err = MapIncrErrU16(f1, at)
   326  		case !as && !incr && f0 == nil:
   327  			err = MapErrU16(f1, at)
   328  		default:
   329  			MapU16(f0, at)
   330  		}
   331  	case Uint32:
   332  		var f0 func(uint32) uint32
   333  		var f1 func(uint32) (uint32, error)
   334  
   335  		switch f := fn.(type) {
   336  		case func(uint32) uint32:
   337  			f0 = f
   338  		case func(uint32) (uint32, error):
   339  			f1 = f
   340  		default:
   341  			return errors.Errorf("Cannot map fn of %T to array", fn)
   342  		}
   343  
   344  		at := a.Uint32s()
   345  		switch {
   346  		case as && incr && f0 != nil:
   347  			at[0] += f0(at[0])
   348  		case as && incr && f0 == nil:
   349  			var tmp uint32
   350  			if tmp, err = f1(at[0]); err != nil {
   351  				return
   352  			}
   353  			at[0] += tmp
   354  		case as && !incr && f0 != nil:
   355  			at[0] = f0(at[0])
   356  		case as && !incr && f0 == nil:
   357  			at[0], err = f1(at[0])
   358  		case !as && incr && f0 != nil:
   359  			MapIncrU32(f0, at)
   360  		case !as && incr && f0 == nil:
   361  			err = MapIncrErrU32(f1, at)
   362  		case !as && !incr && f0 == nil:
   363  			err = MapErrU32(f1, at)
   364  		default:
   365  			MapU32(f0, at)
   366  		}
   367  	case Uint64:
   368  		var f0 func(uint64) uint64
   369  		var f1 func(uint64) (uint64, error)
   370  
   371  		switch f := fn.(type) {
   372  		case func(uint64) uint64:
   373  			f0 = f
   374  		case func(uint64) (uint64, error):
   375  			f1 = f
   376  		default:
   377  			return errors.Errorf("Cannot map fn of %T to array", fn)
   378  		}
   379  
   380  		at := a.Uint64s()
   381  		switch {
   382  		case as && incr && f0 != nil:
   383  			at[0] += f0(at[0])
   384  		case as && incr && f0 == nil:
   385  			var tmp uint64
   386  			if tmp, err = f1(at[0]); err != nil {
   387  				return
   388  			}
   389  			at[0] += tmp
   390  		case as && !incr && f0 != nil:
   391  			at[0] = f0(at[0])
   392  		case as && !incr && f0 == nil:
   393  			at[0], err = f1(at[0])
   394  		case !as && incr && f0 != nil:
   395  			MapIncrU64(f0, at)
   396  		case !as && incr && f0 == nil:
   397  			err = MapIncrErrU64(f1, at)
   398  		case !as && !incr && f0 == nil:
   399  			err = MapErrU64(f1, at)
   400  		default:
   401  			MapU64(f0, at)
   402  		}
   403  	case Uintptr:
   404  		var f0 func(uintptr) uintptr
   405  		var f1 func(uintptr) (uintptr, error)
   406  
   407  		switch f := fn.(type) {
   408  		case func(uintptr) uintptr:
   409  			f0 = f
   410  		case func(uintptr) (uintptr, error):
   411  			f1 = f
   412  		default:
   413  			return errors.Errorf("Cannot map fn of %T to array", fn)
   414  		}
   415  
   416  		at := a.Uintptrs()
   417  		if incr {
   418  			return errors.Errorf("Cannot perform increment on t of %v", t)
   419  		}
   420  		switch {
   421  		case as && f0 != nil:
   422  			at[0] = f0(at[0])
   423  		case as && f0 == nil:
   424  			at[0], err = f1(at[0])
   425  		case !as && f0 == nil:
   426  			err = MapErrUintptr(f1, at)
   427  		default:
   428  			MapUintptr(f0, at)
   429  		}
   430  	case Float32:
   431  		var f0 func(float32) float32
   432  		var f1 func(float32) (float32, error)
   433  
   434  		switch f := fn.(type) {
   435  		case func(float32) float32:
   436  			f0 = f
   437  		case func(float32) (float32, error):
   438  			f1 = f
   439  		default:
   440  			return errors.Errorf("Cannot map fn of %T to array", fn)
   441  		}
   442  
   443  		at := a.Float32s()
   444  		switch {
   445  		case as && incr && f0 != nil:
   446  			at[0] += f0(at[0])
   447  		case as && incr && f0 == nil:
   448  			var tmp float32
   449  			if tmp, err = f1(at[0]); err != nil {
   450  				return
   451  			}
   452  			at[0] += tmp
   453  		case as && !incr && f0 != nil:
   454  			at[0] = f0(at[0])
   455  		case as && !incr && f0 == nil:
   456  			at[0], err = f1(at[0])
   457  		case !as && incr && f0 != nil:
   458  			MapIncrF32(f0, at)
   459  		case !as && incr && f0 == nil:
   460  			err = MapIncrErrF32(f1, at)
   461  		case !as && !incr && f0 == nil:
   462  			err = MapErrF32(f1, at)
   463  		default:
   464  			MapF32(f0, at)
   465  		}
   466  	case Float64:
   467  		var f0 func(float64) float64
   468  		var f1 func(float64) (float64, error)
   469  
   470  		switch f := fn.(type) {
   471  		case func(float64) float64:
   472  			f0 = f
   473  		case func(float64) (float64, error):
   474  			f1 = f
   475  		default:
   476  			return errors.Errorf("Cannot map fn of %T to array", fn)
   477  		}
   478  
   479  		at := a.Float64s()
   480  		switch {
   481  		case as && incr && f0 != nil:
   482  			at[0] += f0(at[0])
   483  		case as && incr && f0 == nil:
   484  			var tmp float64
   485  			if tmp, err = f1(at[0]); err != nil {
   486  				return
   487  			}
   488  			at[0] += tmp
   489  		case as && !incr && f0 != nil:
   490  			at[0] = f0(at[0])
   491  		case as && !incr && f0 == nil:
   492  			at[0], err = f1(at[0])
   493  		case !as && incr && f0 != nil:
   494  			MapIncrF64(f0, at)
   495  		case !as && incr && f0 == nil:
   496  			err = MapIncrErrF64(f1, at)
   497  		case !as && !incr && f0 == nil:
   498  			err = MapErrF64(f1, at)
   499  		default:
   500  			MapF64(f0, at)
   501  		}
   502  	case Complex64:
   503  		var f0 func(complex64) complex64
   504  		var f1 func(complex64) (complex64, error)
   505  
   506  		switch f := fn.(type) {
   507  		case func(complex64) complex64:
   508  			f0 = f
   509  		case func(complex64) (complex64, error):
   510  			f1 = f
   511  		default:
   512  			return errors.Errorf("Cannot map fn of %T to array", fn)
   513  		}
   514  
   515  		at := a.Complex64s()
   516  		switch {
   517  		case as && incr && f0 != nil:
   518  			at[0] += f0(at[0])
   519  		case as && incr && f0 == nil:
   520  			var tmp complex64
   521  			if tmp, err = f1(at[0]); err != nil {
   522  				return
   523  			}
   524  			at[0] += tmp
   525  		case as && !incr && f0 != nil:
   526  			at[0] = f0(at[0])
   527  		case as && !incr && f0 == nil:
   528  			at[0], err = f1(at[0])
   529  		case !as && incr && f0 != nil:
   530  			MapIncrC64(f0, at)
   531  		case !as && incr && f0 == nil:
   532  			err = MapIncrErrC64(f1, at)
   533  		case !as && !incr && f0 == nil:
   534  			err = MapErrC64(f1, at)
   535  		default:
   536  			MapC64(f0, at)
   537  		}
   538  	case Complex128:
   539  		var f0 func(complex128) complex128
   540  		var f1 func(complex128) (complex128, error)
   541  
   542  		switch f := fn.(type) {
   543  		case func(complex128) complex128:
   544  			f0 = f
   545  		case func(complex128) (complex128, error):
   546  			f1 = f
   547  		default:
   548  			return errors.Errorf("Cannot map fn of %T to array", fn)
   549  		}
   550  
   551  		at := a.Complex128s()
   552  		switch {
   553  		case as && incr && f0 != nil:
   554  			at[0] += f0(at[0])
   555  		case as && incr && f0 == nil:
   556  			var tmp complex128
   557  			if tmp, err = f1(at[0]); err != nil {
   558  				return
   559  			}
   560  			at[0] += tmp
   561  		case as && !incr && f0 != nil:
   562  			at[0] = f0(at[0])
   563  		case as && !incr && f0 == nil:
   564  			at[0], err = f1(at[0])
   565  		case !as && incr && f0 != nil:
   566  			MapIncrC128(f0, at)
   567  		case !as && incr && f0 == nil:
   568  			err = MapIncrErrC128(f1, at)
   569  		case !as && !incr && f0 == nil:
   570  			err = MapErrC128(f1, at)
   571  		default:
   572  			MapC128(f0, at)
   573  		}
   574  	case String:
   575  		var f0 func(string) string
   576  		var f1 func(string) (string, error)
   577  
   578  		switch f := fn.(type) {
   579  		case func(string) string:
   580  			f0 = f
   581  		case func(string) (string, error):
   582  			f1 = f
   583  		default:
   584  			return errors.Errorf("Cannot map fn of %T to array", fn)
   585  		}
   586  
   587  		at := a.Strings()
   588  		switch {
   589  		case as && incr && f0 != nil:
   590  			at[0] += f0(at[0])
   591  		case as && incr && f0 == nil:
   592  			var tmp string
   593  			if tmp, err = f1(at[0]); err != nil {
   594  				return
   595  			}
   596  			at[0] += tmp
   597  		case as && !incr && f0 != nil:
   598  			at[0] = f0(at[0])
   599  		case as && !incr && f0 == nil:
   600  			at[0], err = f1(at[0])
   601  		case !as && incr && f0 != nil:
   602  			MapIncrStr(f0, at)
   603  		case !as && incr && f0 == nil:
   604  			err = MapIncrErrStr(f1, at)
   605  		case !as && !incr && f0 == nil:
   606  			err = MapErrStr(f1, at)
   607  		default:
   608  			MapStr(f0, at)
   609  		}
   610  	case UnsafePointer:
   611  		var f0 func(unsafe.Pointer) unsafe.Pointer
   612  		var f1 func(unsafe.Pointer) (unsafe.Pointer, error)
   613  
   614  		switch f := fn.(type) {
   615  		case func(unsafe.Pointer) unsafe.Pointer:
   616  			f0 = f
   617  		case func(unsafe.Pointer) (unsafe.Pointer, error):
   618  			f1 = f
   619  		default:
   620  			return errors.Errorf("Cannot map fn of %T to array", fn)
   621  		}
   622  
   623  		at := a.UnsafePointers()
   624  		if incr {
   625  			return errors.Errorf("Cannot perform increment on t of %v", t)
   626  		}
   627  		switch {
   628  		case as && f0 != nil:
   629  			at[0] = f0(at[0])
   630  		case as && f0 == nil:
   631  			at[0], err = f1(at[0])
   632  		case !as && f0 == nil:
   633  			err = MapErrUnsafePointer(f1, at)
   634  		default:
   635  			MapUnsafePointer(f0, at)
   636  		}
   637  	default:
   638  		return errors.Errorf("Cannot map t of %v", t)
   639  
   640  	}
   641  
   642  	return
   643  }
   644  
   645  func (e E) MapIter(t reflect.Type, fn interface{}, a *storage.Header, incr bool, ait Iterator) (err error) {
   646  	switch t {
   647  	case Bool:
   648  		at := a.Bools()
   649  		var f0 func(bool) bool
   650  		var f1 func(bool) (bool, error)
   651  
   652  		switch f := fn.(type) {
   653  		case func(bool) bool:
   654  			f0 = f
   655  		case func(bool) (bool, error):
   656  			f1 = f
   657  		default:
   658  			return errors.Errorf("Cannot map fn of %T to array", fn)
   659  		}
   660  
   661  		if incr {
   662  			return errors.Errorf("Cannot perform increment on t of %v", t)
   663  		}
   664  		switch {
   665  		case f0 == nil:
   666  			err = MapIterErrB(f1, at, ait)
   667  		default:
   668  			MapIterB(f0, at, ait)
   669  		}
   670  	case Int:
   671  		at := a.Ints()
   672  		var f0 func(int) int
   673  		var f1 func(int) (int, error)
   674  
   675  		switch f := fn.(type) {
   676  		case func(int) int:
   677  			f0 = f
   678  		case func(int) (int, error):
   679  			f1 = f
   680  		default:
   681  			return errors.Errorf("Cannot map fn of %T to array", fn)
   682  		}
   683  
   684  		switch {
   685  		case incr && f0 != nil:
   686  			MapIterIncrI(f0, at, ait)
   687  		case incr && f0 == nil:
   688  			err = MapIterIncrErrI(f1, at, ait)
   689  		case !incr && f0 == nil:
   690  			err = MapIterErrI(f1, at, ait)
   691  		default:
   692  			MapIterI(f0, at, ait)
   693  		}
   694  	case Int8:
   695  		at := a.Int8s()
   696  		var f0 func(int8) int8
   697  		var f1 func(int8) (int8, error)
   698  
   699  		switch f := fn.(type) {
   700  		case func(int8) int8:
   701  			f0 = f
   702  		case func(int8) (int8, error):
   703  			f1 = f
   704  		default:
   705  			return errors.Errorf("Cannot map fn of %T to array", fn)
   706  		}
   707  
   708  		switch {
   709  		case incr && f0 != nil:
   710  			MapIterIncrI8(f0, at, ait)
   711  		case incr && f0 == nil:
   712  			err = MapIterIncrErrI8(f1, at, ait)
   713  		case !incr && f0 == nil:
   714  			err = MapIterErrI8(f1, at, ait)
   715  		default:
   716  			MapIterI8(f0, at, ait)
   717  		}
   718  	case Int16:
   719  		at := a.Int16s()
   720  		var f0 func(int16) int16
   721  		var f1 func(int16) (int16, error)
   722  
   723  		switch f := fn.(type) {
   724  		case func(int16) int16:
   725  			f0 = f
   726  		case func(int16) (int16, error):
   727  			f1 = f
   728  		default:
   729  			return errors.Errorf("Cannot map fn of %T to array", fn)
   730  		}
   731  
   732  		switch {
   733  		case incr && f0 != nil:
   734  			MapIterIncrI16(f0, at, ait)
   735  		case incr && f0 == nil:
   736  			err = MapIterIncrErrI16(f1, at, ait)
   737  		case !incr && f0 == nil:
   738  			err = MapIterErrI16(f1, at, ait)
   739  		default:
   740  			MapIterI16(f0, at, ait)
   741  		}
   742  	case Int32:
   743  		at := a.Int32s()
   744  		var f0 func(int32) int32
   745  		var f1 func(int32) (int32, error)
   746  
   747  		switch f := fn.(type) {
   748  		case func(int32) int32:
   749  			f0 = f
   750  		case func(int32) (int32, error):
   751  			f1 = f
   752  		default:
   753  			return errors.Errorf("Cannot map fn of %T to array", fn)
   754  		}
   755  
   756  		switch {
   757  		case incr && f0 != nil:
   758  			MapIterIncrI32(f0, at, ait)
   759  		case incr && f0 == nil:
   760  			err = MapIterIncrErrI32(f1, at, ait)
   761  		case !incr && f0 == nil:
   762  			err = MapIterErrI32(f1, at, ait)
   763  		default:
   764  			MapIterI32(f0, at, ait)
   765  		}
   766  	case Int64:
   767  		at := a.Int64s()
   768  		var f0 func(int64) int64
   769  		var f1 func(int64) (int64, error)
   770  
   771  		switch f := fn.(type) {
   772  		case func(int64) int64:
   773  			f0 = f
   774  		case func(int64) (int64, error):
   775  			f1 = f
   776  		default:
   777  			return errors.Errorf("Cannot map fn of %T to array", fn)
   778  		}
   779  
   780  		switch {
   781  		case incr && f0 != nil:
   782  			MapIterIncrI64(f0, at, ait)
   783  		case incr && f0 == nil:
   784  			err = MapIterIncrErrI64(f1, at, ait)
   785  		case !incr && f0 == nil:
   786  			err = MapIterErrI64(f1, at, ait)
   787  		default:
   788  			MapIterI64(f0, at, ait)
   789  		}
   790  	case Uint:
   791  		at := a.Uints()
   792  		var f0 func(uint) uint
   793  		var f1 func(uint) (uint, error)
   794  
   795  		switch f := fn.(type) {
   796  		case func(uint) uint:
   797  			f0 = f
   798  		case func(uint) (uint, error):
   799  			f1 = f
   800  		default:
   801  			return errors.Errorf("Cannot map fn of %T to array", fn)
   802  		}
   803  
   804  		switch {
   805  		case incr && f0 != nil:
   806  			MapIterIncrU(f0, at, ait)
   807  		case incr && f0 == nil:
   808  			err = MapIterIncrErrU(f1, at, ait)
   809  		case !incr && f0 == nil:
   810  			err = MapIterErrU(f1, at, ait)
   811  		default:
   812  			MapIterU(f0, at, ait)
   813  		}
   814  	case Uint8:
   815  		at := a.Uint8s()
   816  		var f0 func(uint8) uint8
   817  		var f1 func(uint8) (uint8, error)
   818  
   819  		switch f := fn.(type) {
   820  		case func(uint8) uint8:
   821  			f0 = f
   822  		case func(uint8) (uint8, error):
   823  			f1 = f
   824  		default:
   825  			return errors.Errorf("Cannot map fn of %T to array", fn)
   826  		}
   827  
   828  		switch {
   829  		case incr && f0 != nil:
   830  			MapIterIncrU8(f0, at, ait)
   831  		case incr && f0 == nil:
   832  			err = MapIterIncrErrU8(f1, at, ait)
   833  		case !incr && f0 == nil:
   834  			err = MapIterErrU8(f1, at, ait)
   835  		default:
   836  			MapIterU8(f0, at, ait)
   837  		}
   838  	case Uint16:
   839  		at := a.Uint16s()
   840  		var f0 func(uint16) uint16
   841  		var f1 func(uint16) (uint16, error)
   842  
   843  		switch f := fn.(type) {
   844  		case func(uint16) uint16:
   845  			f0 = f
   846  		case func(uint16) (uint16, error):
   847  			f1 = f
   848  		default:
   849  			return errors.Errorf("Cannot map fn of %T to array", fn)
   850  		}
   851  
   852  		switch {
   853  		case incr && f0 != nil:
   854  			MapIterIncrU16(f0, at, ait)
   855  		case incr && f0 == nil:
   856  			err = MapIterIncrErrU16(f1, at, ait)
   857  		case !incr && f0 == nil:
   858  			err = MapIterErrU16(f1, at, ait)
   859  		default:
   860  			MapIterU16(f0, at, ait)
   861  		}
   862  	case Uint32:
   863  		at := a.Uint32s()
   864  		var f0 func(uint32) uint32
   865  		var f1 func(uint32) (uint32, error)
   866  
   867  		switch f := fn.(type) {
   868  		case func(uint32) uint32:
   869  			f0 = f
   870  		case func(uint32) (uint32, error):
   871  			f1 = f
   872  		default:
   873  			return errors.Errorf("Cannot map fn of %T to array", fn)
   874  		}
   875  
   876  		switch {
   877  		case incr && f0 != nil:
   878  			MapIterIncrU32(f0, at, ait)
   879  		case incr && f0 == nil:
   880  			err = MapIterIncrErrU32(f1, at, ait)
   881  		case !incr && f0 == nil:
   882  			err = MapIterErrU32(f1, at, ait)
   883  		default:
   884  			MapIterU32(f0, at, ait)
   885  		}
   886  	case Uint64:
   887  		at := a.Uint64s()
   888  		var f0 func(uint64) uint64
   889  		var f1 func(uint64) (uint64, error)
   890  
   891  		switch f := fn.(type) {
   892  		case func(uint64) uint64:
   893  			f0 = f
   894  		case func(uint64) (uint64, error):
   895  			f1 = f
   896  		default:
   897  			return errors.Errorf("Cannot map fn of %T to array", fn)
   898  		}
   899  
   900  		switch {
   901  		case incr && f0 != nil:
   902  			MapIterIncrU64(f0, at, ait)
   903  		case incr && f0 == nil:
   904  			err = MapIterIncrErrU64(f1, at, ait)
   905  		case !incr && f0 == nil:
   906  			err = MapIterErrU64(f1, at, ait)
   907  		default:
   908  			MapIterU64(f0, at, ait)
   909  		}
   910  	case Uintptr:
   911  		at := a.Uintptrs()
   912  		var f0 func(uintptr) uintptr
   913  		var f1 func(uintptr) (uintptr, error)
   914  
   915  		switch f := fn.(type) {
   916  		case func(uintptr) uintptr:
   917  			f0 = f
   918  		case func(uintptr) (uintptr, error):
   919  			f1 = f
   920  		default:
   921  			return errors.Errorf("Cannot map fn of %T to array", fn)
   922  		}
   923  
   924  		if incr {
   925  			return errors.Errorf("Cannot perform increment on t of %v", t)
   926  		}
   927  		switch {
   928  		case f0 == nil:
   929  			err = MapIterErrUintptr(f1, at, ait)
   930  		default:
   931  			MapIterUintptr(f0, at, ait)
   932  		}
   933  	case Float32:
   934  		at := a.Float32s()
   935  		var f0 func(float32) float32
   936  		var f1 func(float32) (float32, error)
   937  
   938  		switch f := fn.(type) {
   939  		case func(float32) float32:
   940  			f0 = f
   941  		case func(float32) (float32, error):
   942  			f1 = f
   943  		default:
   944  			return errors.Errorf("Cannot map fn of %T to array", fn)
   945  		}
   946  
   947  		switch {
   948  		case incr && f0 != nil:
   949  			MapIterIncrF32(f0, at, ait)
   950  		case incr && f0 == nil:
   951  			err = MapIterIncrErrF32(f1, at, ait)
   952  		case !incr && f0 == nil:
   953  			err = MapIterErrF32(f1, at, ait)
   954  		default:
   955  			MapIterF32(f0, at, ait)
   956  		}
   957  	case Float64:
   958  		at := a.Float64s()
   959  		var f0 func(float64) float64
   960  		var f1 func(float64) (float64, error)
   961  
   962  		switch f := fn.(type) {
   963  		case func(float64) float64:
   964  			f0 = f
   965  		case func(float64) (float64, error):
   966  			f1 = f
   967  		default:
   968  			return errors.Errorf("Cannot map fn of %T to array", fn)
   969  		}
   970  
   971  		switch {
   972  		case incr && f0 != nil:
   973  			MapIterIncrF64(f0, at, ait)
   974  		case incr && f0 == nil:
   975  			err = MapIterIncrErrF64(f1, at, ait)
   976  		case !incr && f0 == nil:
   977  			err = MapIterErrF64(f1, at, ait)
   978  		default:
   979  			MapIterF64(f0, at, ait)
   980  		}
   981  	case Complex64:
   982  		at := a.Complex64s()
   983  		var f0 func(complex64) complex64
   984  		var f1 func(complex64) (complex64, error)
   985  
   986  		switch f := fn.(type) {
   987  		case func(complex64) complex64:
   988  			f0 = f
   989  		case func(complex64) (complex64, error):
   990  			f1 = f
   991  		default:
   992  			return errors.Errorf("Cannot map fn of %T to array", fn)
   993  		}
   994  
   995  		switch {
   996  		case incr && f0 != nil:
   997  			MapIterIncrC64(f0, at, ait)
   998  		case incr && f0 == nil:
   999  			err = MapIterIncrErrC64(f1, at, ait)
  1000  		case !incr && f0 == nil:
  1001  			err = MapIterErrC64(f1, at, ait)
  1002  		default:
  1003  			MapIterC64(f0, at, ait)
  1004  		}
  1005  	case Complex128:
  1006  		at := a.Complex128s()
  1007  		var f0 func(complex128) complex128
  1008  		var f1 func(complex128) (complex128, error)
  1009  
  1010  		switch f := fn.(type) {
  1011  		case func(complex128) complex128:
  1012  			f0 = f
  1013  		case func(complex128) (complex128, error):
  1014  			f1 = f
  1015  		default:
  1016  			return errors.Errorf("Cannot map fn of %T to array", fn)
  1017  		}
  1018  
  1019  		switch {
  1020  		case incr && f0 != nil:
  1021  			MapIterIncrC128(f0, at, ait)
  1022  		case incr && f0 == nil:
  1023  			err = MapIterIncrErrC128(f1, at, ait)
  1024  		case !incr && f0 == nil:
  1025  			err = MapIterErrC128(f1, at, ait)
  1026  		default:
  1027  			MapIterC128(f0, at, ait)
  1028  		}
  1029  	case String:
  1030  		at := a.Strings()
  1031  		var f0 func(string) string
  1032  		var f1 func(string) (string, error)
  1033  
  1034  		switch f := fn.(type) {
  1035  		case func(string) string:
  1036  			f0 = f
  1037  		case func(string) (string, error):
  1038  			f1 = f
  1039  		default:
  1040  			return errors.Errorf("Cannot map fn of %T to array", fn)
  1041  		}
  1042  
  1043  		switch {
  1044  		case incr && f0 != nil:
  1045  			MapIterIncrStr(f0, at, ait)
  1046  		case incr && f0 == nil:
  1047  			err = MapIterIncrErrStr(f1, at, ait)
  1048  		case !incr && f0 == nil:
  1049  			err = MapIterErrStr(f1, at, ait)
  1050  		default:
  1051  			MapIterStr(f0, at, ait)
  1052  		}
  1053  	case UnsafePointer:
  1054  		at := a.UnsafePointers()
  1055  		var f0 func(unsafe.Pointer) unsafe.Pointer
  1056  		var f1 func(unsafe.Pointer) (unsafe.Pointer, error)
  1057  
  1058  		switch f := fn.(type) {
  1059  		case func(unsafe.Pointer) unsafe.Pointer:
  1060  			f0 = f
  1061  		case func(unsafe.Pointer) (unsafe.Pointer, error):
  1062  			f1 = f
  1063  		default:
  1064  			return errors.Errorf("Cannot map fn of %T to array", fn)
  1065  		}
  1066  
  1067  		if incr {
  1068  			return errors.Errorf("Cannot perform increment on t of %v", t)
  1069  		}
  1070  		switch {
  1071  		case f0 == nil:
  1072  			err = MapIterErrUnsafePointer(f1, at, ait)
  1073  		default:
  1074  			MapIterUnsafePointer(f0, at, ait)
  1075  		}
  1076  	default:
  1077  		return errors.Errorf("Cannot map t of %v", t)
  1078  	}
  1079  
  1080  	return
  1081  }