1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
" list#flat([elem, ...]) {{{1
"
" Flatten the arguments into a single list.
"
" given: a = ['a', 'b']
"        b = [1, 2]
" list#flat(a,b)      : ['a', 'b', 1,  2]
"
function! list#flat(...)
  let fl = []
  let list = a:000
  if a:0 == 1
    let list = list[0]
  endif
  for el in list
    if type(el) == type([])
      call extend(fl, list#flat(el))
    else
      call extend(fl, [el])
    endif
    unlet el
  endfor
  return fl
endfunction

function! list#split(list, match)
  let ret = []
  let r = []
  for e in a:list
    if e =~ a:match
      call add(ret, r)
      let r = []
    else
      call add(r, e)
    endif
  endfor
  call add(ret, r)
  return ret
endfunction

" list#zip(list_a, list_b, method) {{{1
"
" Join each element of list_a with the corresponding element of list_b
" Use the third argument, method, to dictate how the elements should be
" combined:
" given: a = [a, b]
"        b = [1, 2]
" 0 = flattened list  : [a, 1, b, 2]
" 1 = list groups     : [[a, 1], [b, 2]]
" x = join separator x : [ax1, bx2]
"
" NOTE: If one list is longer than the other, the tail of that list is added
" to the result.
function! list#zip(a, b, ...)
  let method = 1
  if a:0
    let method = a:1
  endif
  let i = 0
  let r = []
  let l_a = len(a:a)
  let l_b = len(a:b)
  let n = min([len(a:a), len(a:b)])
  while i < n
    if method == "0"
      call add(r, a:a[i])
      call add(r, a:b[i])
    elseif method == "1"
      call add(r, [a:a[i], a:b[i]])
    else
      call add(r, join([a:a[i], a:b[i]], method))
    endif
    let i+= 1
  endwhile
  if l_a == l_b
    return r
  elseif l_a > l_b
    exe "return r + a:a[" . n . ":]"
  else
    exe "return r + a:b[" . n . ":]"
  endif
endfunction "}}}1

" list#inject(list, init, funcref)
function! list#inject(list, init, funcref)
  if ! exists('*' . a:funcref)
    throw 'vimple: list#inject(): Funcref ' . a:funcref . ' does not exist!'
    return a:init
  elseif empty(a:list)
    return a:init
  else
    let i  = a:list[0]
    let r  = a:list[1:-1]
    let v = call(a:funcref, [a:init, i])
    return list#inject(r, v, a:funcref)
  endif
endf

" partition list into count-element sublists
function! list#partition(list, count)
  let lst = deepcopy(a:list)
  let len = len(lst)
  let cnt = a:count
  let newlists = []
  if cnt <= 0
    throw 'vimple: list#partition: count must be positive'
  endif
  if cnt >= len
    return lst
  endif
  for idx in range(0, len - 1, cnt)
    if cnt > len(lst)
      let cnt = len(lst)
    endif
    call add(newlists, remove(lst, 0, (cnt - 1)))
  endfor
  return newlists
endfunc

" partition list into cols sublists and join with colsep=\t
" list#lspread(list, cols, colsep="\t")
" returns a list
function! list#lspread(list, cols, ...)
  let colsep = "\t"
  if a:0
    let colsep = a:1
  endif
  return map(list#partition(a:list, a:cols), 'join(v:val, "' . escape(colsep, '"') . '")')
endfunction

" partition list into cols sublists and join with col and row seps
" list#spread(list, cols, colsep, rowsep)
" returns a string
function! list#spread(list, cols, ...)
  let colsep = "\t"
  let rowsep = "\n"
  if a:0
    if a:0 == 2
      let colsep = a:1
      let rowsep = a:2
    else
      let colsep = a:1
    endif
  endif
  return join(list#lspread(a:list, a:cols, colsep), rowsep)
endfunction

" " map expr over each element of each sublist of list
" function! list#lmap(list, expr)
"   return map(a:list, 'map(v:val, ''' . a:expr . ''')')
" endfunction

function! list#shuffle(a)
  let b = deepcopy(a:a)
  let n = 0
  let length = len(b)
  while n < length
    let tmp = b[n]
    let dst = rng#rand() % length
    let b[n] = b[dst]
    let b[dst] = tmp
    let n += 1
  endwhile
  return b
endfunction

" list#paste(a, b, join, sep)
" Emulate the unix paste command
" Arguments:
"   a    - each of 'a' and 'b' are lists, or
"   b    -   strings containing 'sep' (default='\n') delimited elements
"   join - separator (default=' ') to use when joining each respective line of
"          a and b
"   sep  - separator (default='\n') to use when splitting a and b (if strings)
" e.g.
" ------v yank following into register a - "a3yy
" one
" two
" three
" ------v yank following into register b - "b3yy
" satu
" dua
" tiga
" call append('.', Paste(@a, @b))
function! list#paste(a, b, ...)
  let join = (a:0 >= 1) ? a:1 : ' '
  let sep = (a:0 == 2) ? a:2 : '\n'
  if type(a:a) == 1
    let a = split(a:a, sep)
    let b = split(a:b, sep)
  else
    let a = a:a
    let b = a:b
  end
  return list#zip(a, b, join)
endfunction

" list#lrotate(array)
" Perform a Left Rotate on array
function! list#lrotate(a)
  return extend(a:a[1:-1], [a:a[0]])
endfunction

" list#rrotate(array)
" Perform a Right Rotate on array
function! list#rrotate(a)
  return extend([a:a[-1]], a:a[0:-2])
endfunction