-- t=table
-- cm=compact output. if true,
--  no newlines or indentation
--  are added.
-- ind=indent size
-- l=indent level
-- lst=last item in table?
-- in practice, you only need
-- to provide the first
-- argument. the others are for
-- tweaking output spacing
-- (ind and l) and, in the case
-- of lst, for internal use by
-- the function .
-- does not currently handle
-- recursive tables, so be
-- careful not to create
-- infinite loops in any tables
-- you send to this function.
function strngfy(t,co,ind,l,lst)
 -- make sure ind, l, lst, and
 -- co have sane values. prep
 -- some other variables for
 -- use. we're shadowing ind,
 -- but i don't think it should
 -- matter under any reasonable
 -- set of assumptions.
 local ind,l,lst,co,tp,st
  =max(ind or 2,ind),l and l or
  0,lst or false,co or false
  ,type(t),""
 --------
 l=co and 0 or l+1
 local sp=rptsp(l*ind)
 if tp=='table' then
  local cnt=tcnt(t)
  st..="{"..(co and "" or "\n")
  -- order is not guaranteed, so
  -- two executions of this loop
  -- on the same table might
  -- produce two different
  -- orders of the keys in the
  -- output.
  -- ipairs() does guarantee
  -- order, but only iterates
  -- over consecutive numerical
  -- indices, and is therefore
  -- useless if we want to deal
  -- with sparsely-keyed tables,
  -- or tables which can have
  -- other tables for keys.
  for k,v in next,t do
   st..=sp.."["..strngfy(k,co,
    ind,l,cnt>1).."] => "..
    strngfy(v,co,ind,l,cnt>1)
    ..(cnt>1 and ","..(co and ""
    or "\n") or "")
   cnt-=1
  end
  l-=1
  local sp=rptsp(l*ind)
  st..=(co and "" or "\n")..sp
   .."}"..(cnt > 1 and ","
   or "")
 else 
  st..=tp=="function" and
    "<function>" or tp=="boolean"
    and t==true and "true" or
    t==false and "false" or
    tp=="nil" and "nil" or t
 end

 return st
end

-- a special case of rptchr()
-- that only produces spaces.
function rptsp(c)
 c=c>0 and c or 0
 s=""
 for i=1,c do
  s..=" "
 end

 return s
end

-- insanity, but as far as i can
-- tell, this is the only way to
-- get the number of entries in
-- a table that doesn't have
-- contiguous numerical keys.
function tcnt(t)
  if type(t) ~= "table" then
   -- to remove ambiguity
   -- between this and a table
   -- with no entries.
   return -1
  end
  local cnt=0
  for _ in pairs(t) do
   cnt+=1
  end

  return cnt
end

tablekey={thisisakey="asdf",thisisanotherkey="fdsa"}
itable={thisis="an internal table", witha=tinternaltable}
tablekey[itable]={yetanother="table"}
tinternaltable={tintkey="tintvalue"}
tablekey[itable][tinternaltable] = "final"
table={}
table[tablekey]="some value"
table.stringkey="stringkey value"
omt={onemore="table",withsome="values",includingint=128,float=2.24}
omtv={okthis="is the last one", i={pinky="promise"}}
table.stringkeyb={
  stkb="a value in a table",
  stkc=32,
  stkd={},
  stke={}
}
table.stringkeyb.stke[omt]=omtv

printh(strngfy(table))

{
  [stringkey] => stringkey value,
  [stringkeyb] => {
    [stke] => {
      [{
        [includingint] => 128,
        [float] => 2.24,
        [onemore] => table,
        [withsome] => values
      }] => {
        [okthis] => is the last one,
        [i] => {
          [pinky] => promise
        }
      }
    },
    [stkd] => {

    },
    [stkc] => 32,
    [stkb] => a value in a table
  },
  [{
    [thisisanotherkey] => fdsa,
    [{
      [thisis] => an internal table
    }] => {
      [{
        [tintkey] => tintvalue
      }] => final,
      [yetanother] => table
    },
    [thisisakey] => asdf
  }] => some value
}