LURE: lists

local R=require "random"

local function member(x,t)
  for _,y in pairs(t) do
    if x== y then return true end end
  return false end

local function first(x)  return x[1] end

local function last(x)  return x[#x] end

local function push(t,x)   
 t[#t+1] = x
 return x end

local function shuffle( t )
  for i= 1,#t do
    local j = i + math.floor((#t - i) * R.r() + 0.5)
    t[i],t[j] = t[j], t[i] 
  end
  return t end

local function any(t)
  return t[ math.floor((#t-1) * R.r() + 0.5) ]
end

local function some(t,cols)
  local i = 0
  return function ()
    if i < #cols then
      i= i+1
      return t[cols[i]] end end end

local function sort(t,f)
  f=f or function (x,y) return x < y end
  table.sort(t,f)
  return t end

local function firsts(x,y)
  return first(x) < first(y) end

local function lasts(x,y)
  return last(x) < last(y) end

local function without(t,n)
  out={}
  for j,x in pairs(t) do
    if j ~= n then
      push(out,x) end end
  return out
end

local function bsearch(t,val,f) 
  f = f or function (t,x) return t[x] end
  local lo,hi=1,#t
  while lo <= hi do
    local mid = (lo+hi)/2
    mid = math.floor(mid)
    if f(t,mid) >= val then
      hi = mid - 1
    else
      lo = mid + 1 end end
  return math.min(lo,#t)  end

local function map(t,f)
  if t then
    for i,v in pairs(t) do f(v) end end end

local function map2(t,w,f)
  if t then
    for _,v in pairs(t) do f(w,v) end
  end
  return w end

local function collect(t,f)
  local out={}
  if t then
    for i,v in pairs(t) do out[i] = f(v) end end
  return out end

local function maprint(t, first, last)
  first = first or #t
  for j=1,first do print(j,t[j]) end
  if last then
    print("...")
    for j=#t+last, #t do print(j,t[j]) end end end

local function mprint(ts,sep) 
  sep = sep or ", "
  local fmt,w={},{}
  local function width(col,x)
    if not w[col] then w[col]=0 end
    local tmp= #tostring(x)
    if tmp > w[col] then 
      w[col] = tmp 
      fmt[col] = "%" .. tmp .. "s" end 
  end ----------------------------
  for _,t in pairs(ts) do
    for col,x in pairs(t) do width(col,x) end end
  for i,t in pairs(ts) do
    io.write(
      string.format(
        table.concat(fmt,sep)  .. "\n",
        unpack(t))) end end

local function same(x) return x end

local function shallowCopy(t) return collect(t,same) end

local function copy(t)  --recursive       
  return type(t) ~= 'table' and t or collect(t,copy) end

return { maprint=maprint,sort=sort,mprint=mprint,
         without=without, firsts=firsts,lasts=lasts,first=first, last=last,same=same,copy=copy,
         shallowCopy=shallowCopy, member=member,map=map, bsearch=bsearch,
         push=push,map2=map2, collect=collect,shuffle=shuffle}