{def stack.add
 {lambda {:v :s}
  {let { {_ {A.addfirst! :v :s}}}
       } ok}}
-> stack.add

{def stack.get
 {lambda {:s}
  {let { {:v {A.first :s}}
         {_ {A.subfirst! :s}}
       } :v}}}
-> stack.get

{def stack.peek
 {lambda {:s}
  {A.first :s}}}
-> stack.peek

{def stack.empty?
 {lambda {:s}
  {A.empty? :s}}}
-> stack.empty?

{def S {A.new}}    -> S      []
{stack.add 1 {S}}  ->  ok    [1]
{stack.add 2 {S}}  ->  ok    [2,1]
{stack.add 3 {S}}  ->  ok    [3,2,1]
{stack.empty? {S}} -> false
{stack.get {S}}    -> 3      [2,1]
{stack.add 4 {S}}  ->  ok    [4,2,1]
{stack.peek {S}}   -> 4      [4,2,1]
{stack.get {S}}    -> 4      [2,1]
{stack.get {S}}    -> 2      [1]
{stack.get {S}}    -> 1      []
{stack.get {S}}    -> undefined
{stack.empty? {S}} -> true