Stack: Difference between revisions

{{trans|Crystal}}

 

 

L(i) 1..10

 

L 10

 

{{out}}

 

Push:

Pop:

Empty:

CPX $FF

Peek:

 

=={{header|68000 Assembly}}==

===Push===

You can push the contents of one or more variables.

 

Unlike the "true" stack (A7), you can push a single byte onto the user stack and it won't get automatically padded with a trailing null byte.

===Pop===

The pop is just a reverse push.

 

===Empty===

The stack is empty if and only if the stack pointer equals its initialized value. This is only true provided you have never adjusted the stack pointer except by pushing and popping.

 

===Manually adjusting the stack===

You can offset the user stack (and the real stack) as follows:

 

===Peek===

If you know the intended length of the last item on the stack (1, 2, or 4 bytes), you can load it into memory without popping it. This applies to both the real stack and a user stack you may have created. Since this operation doesn't alter the value of the stack pointer, you don't have to worry about misaligning the stack, but the value you peek at should be of the correct size or you'll be "peeking" at more than one item at the same time.

 

 

=={{header|8086 Assembly}}==

The 8086's hardware stack is very similar to that of [[Z80 Assembly]]. This is no coincidence, as the Z80 was based on the predecessor to the 8086.

 

 

The "high" byte is pushed first, then the low byte. Popping does the opposite.

 

The easiest way to "peek" is to pop then push that same register again.

pop ax

 

The stack need not be accessed using these push and pop commands, it can also be read like any other area of memory. This is actually how [[C]] programs store and recall local variables and function arguments.

This works for ABAP Version 7.40 and above

 

report z_stack.

 

stack3->pop( ).

write: |pop -> Stack3 = { stack3->stringify( ) }|, /, /.

 

{{out}}

=={{header|Action!}}==

===Static memory===

BYTE ARRAY stack(MAXSIZE)

BYTE stacksize=[0]

TestPop()

TestPop()

 

===Dynamic memory===

The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>

{{libheader|Action! Tool Kit}}

 

INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!

TestPop()

TestPop()

{{out}}

Error at the end of program is intentional.

=={{header|ActionScript}}==

In ActionScript an Array object provides stack functionality.

stack.push(1);

stack.push(2);

trace(stack.pop()); // outputs "2"

 

=={{header|Ada}}==

This is a generic stack implementation.

type Element_Type is private;

package Generic_Stack is

Next : Stack := null;

end record;

 

package body Generic_Stack is

end Pop;

 

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.7 algol68g-2.7].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

CO REQUIRES:

MODE OBJVALUE = ~ # Mode/type of actual obj to be stacked #

 

PROC obj nextlink free = (REF OBJNEXTLINK free)VOID:

CO REQUIRES:

MODE OBJNEXTLINK = STRUCT(

self IS obj stack empty;

 

MODE DIETITEM = STRUCT(

STRING food, annual quantity, units, REAL cost

("Wheat Flour", "370","lb.", 13.33),

("Total Annual Cost", "","", 39.93)

# -*- coding: utf-8 -*- #

 

# OR example stack ISNT obj stack empty #

printf((diet item fmt, obj stack pop(example stack), $l$))

{{out}}

<pre>

===ALGOL 68: Using FLEX array===

An alternative to using a linked list is to use a FLEX array.

MODE DIETITEM = STRUCT (

STRING food, annual quantity, units, REAL cost

printf((diet item fmt, POP example stack, $l$))

OD

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% define a Stack type that will hold StringStackElements %

% and the StringStackElement type %

)

end

{{out}}

<pre>

 

=={{header|Applesoft BASIC}}==

110 DATA "(2*A)","PI","","TO BE OR","NOT TO BE"

120 FOR I = 1 TO 5

730 LET EMPTY = SP = 0

740 RETURN

 

{{out}}

 

Pushing and popping multiple values is very similar to [[68000 Assembly]].

LDMFD sp!,{r0-r12,pc} ;pop r0 thru r12, and the value that was in the link register is put into the program counter.

 

Like in 68000 Assembly, you are not limited to using <code>SP</code> as the source/destination for these commands; any register can fulfill that role. If you wish to have multiple stacks, then so be it.

The stack pointer will work with any operation the other registers can. As such, a peek can be done by using an <code>LDR</code> with the stack pointer as the address register:

 

 

The order in which registers are pushed/popped is always the same, no matter which order you list the registers in your source code. If you want to push some registers and purposefully pop them into different registers, you'll need to push/pop them separately.

A check if the stack is empty is also very simple, provided the initial value of the stack pointer was saved at the start of the program, or (more likely) was loaded from a nearby memory location.

 

InitStackPointer: .long 0x3FFFFFFF ;other assemblers would call this a "word"

 

;There's no point in checking since we haven't pushed/popped anything but just for demonstration purposes we'll check now

CMP SP,R2

 

In THUMB mode, the <code>PUSH</code> and <code>POP</code> commands replace <code>STMFD</code> and <code>LDMFD</code>. They work in a similar fashion, but are limited to just the stack unlike the real <code>STMFD</code> and <code>LDMFD</code> commands which can use any register as the "stack pointer."

 

=={{header|Arturo}}==

 

pushTo: function [st val]-> 'st ++ val

 

emptyStack st

 

{{out}}

one two

finally: []</pre>

 

=={{header|AutoHotkey}}==

msgbox % stack("push", 5)

msgbox % stack("peek")

return 0

}

 

=={{header|AWK}}==

arr["start"] = 0

arr["end"] = 0

}

printdeque(q)

 

=={{header|Axe}}==

 

Lbl PUSH

r₁→{L₁+S}ʳ

Lbl EMPTY

S≤≤0

 

=={{header|Babel}}==

{ (1 2 3) foo set -- foo = (1 2 3)

4 foo push -- foo = (1 2 3 4)

"empty" .

cr << }

{{out}}

<pre>

=={{header|Batch File}}==

This implementation uses an environment variable naming convention to implement a stack as a pseudo object containing a pseudo dynamic array and top attribute, as well as an empty "method" that is a sort of macro. The implementation depends on delayed expansion being enabled at the time of each call to a stack function. More complex variations can be written that remove this limitation.

setlocal enableDelayedExpansion

 

if !%~1.top! equ 0 exit /b 1

for %%N in (!%~1.top!) do set %~2=!%~1.%%N!

 

{{works with|BBC BASIC for Windows}}

FOR n = 3 TO 5

= (sptr% = 0)

ENDCASE

{{out}}

<pre>

Representing the stack as an array, pushing is appending, popping is removing the last element, and checking emptiness is checking the length.

 

∾

Pop ← ¯1⊸↓

0

Empty ⟨⟩

 

=={{header|Bracmat}}==

A stack is easiest implemented as a dotted list <code>top.top-1.top-2.<i>[...]</i>.</code>. In the example below we also introduce a 'class' <code>stack</code>, instantiated in the 'object' <code>Stack</code>. The class has a member variable <code>S</code> and methods <code>push</code>,<code>pop</code>, <code>top</code> and <code>empty</code>. As a side note, <code>.</code> is to <code>..</code> as C's <code>.</code> is to <code>-&gt;</code>. In a method's body, <code>its</code> refers to the object itself. (Analogous to <code>(*this)</code> in C++.)

= (S=)

(push=.(!arg.!(its.S)):?(its.S))

)

&

{{out}}

<pre>not to be

Built in arrays have push, pop, and empty? methods:

 

stack.push 1

stack.push 2

stack.push 3

 

 

{{out}}

=={{header|C}}==

Macro expanding to type flexible stack routines.

#include <stdlib.h>

 

stk_int_delete(stk);

return 0;

===Or===

#include <stdlib.h>

#include <stddef.h>

s->bottom = realloc(s->bottom, new_size);

check_pointer(s->bottom);

 

=={{header|C sharp|C#}}==

System.Collections.Stack stack = new System.Collections.Stack();

stack.Push( obj );

bool isEmpty = stack.Count == 0;

Foo top = stack.Peek(); // Peek without Popping.

 

=={{header|C++}}==

{{libheader|STL}}

The C++ standard library already provides a ready-made stack class. You get it by writing

and then using the <tt>std::stack</tt> class.

 

An example of an explicit implementation of a stack class (which actually implements the standard stack class, except that the standard one is in namespace std):

template <class T, class Sequence = std::deque<T> >

class stack {

{

return !(x < y);

 

=={{header|Clojure}}==

As is mentioned in the Common Lisp example below, built in cons-based lists work just fine. In this implementation, the list is wrapped in a datatype, providing a stateful solution.

 

(def stack (Stack (ref ())))

(defn empty-stack?

"Tests whether or not the stack is empty."

 

We can make this a bit smaller and general by using defprotocol along with deftype. Here is a revised version using defprotocol.

 

(push-stack [this x] "Pushes an item to the top of the stack.")

(pop-stack [this] "Pops an item from the top of the stack.")

(empty-stack? [] (= () (deref elements))))

 

 

=={{header|CLU}}==

stack = cluster [T: type] is new, push, pop, peek, empty

rep = array[T]

stream$putl(po, "The stack is empty.")

end

{{out}}

<pre>10

 

stack.cbl

05 head USAGE IS POINTER VALUE NULL.

 

node.cbl

COPY node-info REPLACING

01 BY 05

node-info BY info.

05 link USAGE IS POINTER VALUE NULL.

 

node-info.cbl

 

p.cbl

88 nil VALUE ZERO WHEN SET TO FALSE IS 1.

88 t VALUE 1 WHEN SET TO FALSE IS ZERO.

 

stack-utilities.cbl

PROGRAM-ID. push.

DATA DIVISION.

GOBACK.

END PROGRAM traverse-stack.

 

stack-test.cbl

PROGRAM-ID. stack-test.

DATA DIVISION.

 

COPY stack-utilities.

 

{{out}}

 

=={{header|CoffeeScript}}==

stack.push 1

stack.push 2

console.log stack

console.log stack.pop()

 

=={{header|Common Lisp}}==

It's a bit unusual to write a wrapper for a stack in Common Lisp; built-in cons-based lists work just fine. Nonetheless, here's an implementation where the list is wrapped in a structure, providing a stateful solution.

elements)

 

 

(defun stack-peek (stack)

 

=={{header|Component Pascal}}==

Works with BlackBox Component Builder

MODULE Stacks;

IMPORT StdLog;

END Stacks.

 

Execute: ^Q Stacks.TestStack<br/>

=={{header|Crystal}}==

 

(1..10).each do |x|

stack.push x

10.times do

puts stack.pop

 

'''Output:'''

=={{header|D}}==

Generic stack class implemented with a dynamic array.

 

class Stack(T) {

assert(s.pop() == 10);

assert(s.empty());

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lStack.Free;

end;

 

=={{header|DWScript}}==

Dynamic arrays have pseudo-methods that allow to treat them as a stack.

var stack: array of Integer;

 

 

Assert(stack.Length = 0); // assert empty

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

}

return e

}

var stack = Stack()

 

{{out}}

 

=={{header|Déjà Vu}}==

 

push-to stack 1

 

if stack: #empty lists are falsy

 

=={{header|E}}==

The standard FlexList data structure provides operations for use as a stack.

# value: [].diverge()

 

 

? l.size().aboveZero()

Here's a stack implemented out of a reference to a linked list:

var store := null

def stack {

 

? s.empty()

 

=={{header|EchoLisp}}==

Named stacks are native objects. The following demonstrates the available operations :

; build stack [0 1 ... 9 (top)] from a list

(list->stack (iota 10) 'my-stack)

⛔ error: #|user| : unbound variable : my-stack

(stack-top 'my-stack) → 7

 

=={{header|Eiffel}}==

class

STACK_ON_ARRAY

 

end

 

=={{header|Elena}}==

{

var stack := new system'collections'Stack();

var isEmpty := stack.Length == 0;

item := stack.pop()

 

=={{header|Elisa}}==

This is a generic Stack component based on arrays. See how in Elisa [http://jklunder.home.xs4all.nl/elisa/part01/doc120.html generic components] are defined.

type Stack;

Stack (MaxSize = integer) -> Stack;

stack.index:=stack.index - 1;

stack.area[stack.index + 1] ];

Another example of a generic Stack component is based on an unlimited sequence. A sequence is a uni-directional list. See how Elisa defines [http://jklunder.home.xs4all.nl/elisa/part02/doc010.html sequences]. The component has the same interface as the array based version.

type Stack;

Stack(MaxSize = integer) -> Stack;

Pull ( stack ) = [ exception (Empty (stack), "Stack Underflow");

Head = head(stack.list); stack.list:=tail(stack.list); Head];

Both versions give the same answers to the following tests:

type Book = text;

BookStack = StackofBooks(50);

 

Pull (BookStack)?

 

=={{header|Elixir}}==

{{trans|Erlang}}

def new, do: []

def top([h|_]), do: h

 

Example:

=={{header|Erlang}}==

Erlang has no built-in stack, but its lists behave basically the same way. A stack module can be implemented as a simple wrapper around lists:

-export([empty/1, new/0, pop/1, push/2, top/1]).

 

push(H,T) -> [H|T].

 

Note that as Erlang doesn't have mutable data structure (destructive updates), pop returns the popped element and the new stack as a tuple.

 

The module is tested this way:

{ok,stack}

2> Stack = stack:new().

false

7> stack:empty(stack:new()).

 

=={{header|F_Sharp|F#}}==

 

A list-based immutable stack type could be implemented like this:

(?items) =

let items = defaultArg items []

let (x, stack3) = stack2.Pop()

printfn "%d" x

 

=={{header|Factor}}==

Factor is a stack based language, but also provides stack "objects", because

all resizable sequences can be treated as stacks (see [http://docs.factorcode.org/content/article-sequences-stacks.html docs]). Typically, a vector is used:

[ 6 swap push ]

[ "hi" swap push ]

Let's pop it: "hi"

Vector is now: V{ 1 2 3 6 }

 

=={{header|Forth}}==

create here cell+ , cells allot ;

 

st empty? . \ 0 (false)

st pop . st pop . st pop . \ 3 2 1

 

=={{header|Fortran}}==

This solution can easily be adapted to data types other than floating point numbers.

 

implicit none

end do

call my_stack%clearStack()

 

=={{header|Free Pascal}}==

===Delphi adaptation===

Example taken and adapted from the Delphi entry.

{$IFDEF FPC}{$MODE DELPHI}{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}{$ENDIF}

{$ASSERTIONS ON}

lStack.Free;

end;

<pre>

Output:

===Object version from scratch===

{{works with|Free Pascal|version 3.2.0 }}

PROGRAM StackObject.pas;

{$IFDEF FPC}

What happens after retrieving the variable is TBD by you.

 

(*)

 

END.

 

 

Output:

=={{header|FreeBASIC}}==

We first use a macro to define a generic Stack type :

 

' stack_rosetta.bi

End Function

 

We now use this type to create a Stack of Dog instances :

 

#Include "stack_rosetta.bi"

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Frink}}==

Frink's <CODE>array</CODE> class has all of the methods to make it usable as a stack or a deque. The methods are called <CODE><I>array</I>.push[<I>x</I>]</CODE>, <CODE><I>array</I>.pop[]</CODE>, and <CODE><I>array</I>.isEmpty[]</CODE>

a.push[1]

a.push[2]

a.peek[]

while ! a.isEmpty[]

 

=={{header|Genie}}==

/*

Stack, in Genie, with GLib double ended Queues

print "stack size before clear: " + stack.get_length().to_string()

stack.clear()

 

{{out}}

=={{header|Go}}==

Go slices make excellent stacks without defining any extra types, functions, or methods. For example, to keep a stack of integers, simply declare one as,

Use the built in append function to push numbers on the stack:

Use a slice expression with the built in len function to pop from the stack:

The test for an empty stack:

And to peek at the top of the stack:

It is idiomatic Go to use primitive language features where they are sufficient, and define helper functions or types and methods only as they make sense for a particular situation. Below is an example using a type with methods and idiomatic "ok" return values to avoid panics. It is only an example of something that might make sense in some situation.

 

import "fmt"

fmt.Println("nothing to pop")

}

{{out}}

<pre>

top value: four

four popped. stack: [3]

</pre>

 

 

Of course, these stack semantics are not ''exclusive''. Elements of the list can still be accessed and manipulated in myriads of other ways.

assert stack.empty

 

assert stack.empty

 

 

{{out}}

=={{header|Haskell}}==

The Haskell solution is trivial, using a list. Note that <code>pop</code> returns both the element and the changed stack, to remain purely functional.

 

create :: Stack a

peek :: Stack a -> a

peek [] = error "Stack empty"

We can make a stack that can be destructively popped by hiding the list inside a <code>State</code> monad.

 

type Stack a b = State [a] b

 

nonEmpty :: Stack a ()

 

=={{header|Icon}} and {{header|Unicon}}==

The programmer is free to use any or all of the list processing functions on any problem.

The following illustrates typical stack usage:

stack := [] # new empty stack

push(stack,1) # add item

procedure top(x) #: return top element w/o changing stack

return x[1] # in practice, just use x[1]

 

=={{header|Io}}==

aside from using built-in lists, a stack can be created using nodes like so:

next := nil

obj := nil

self node = nn

)

 

=={{header|Ioke}}==

initialize = method(@elements = [])

pop = method(@elements pop!)

empty = method(@elements empty?)

push = method(element, @elements push!(element))

 

=={{header|IS-BASIC}}==

110 NUMERIC STACK(1 TO N)

120 LET PTR=1

300 DEF TOP=STACK(PTR-1)

310 CALL PUSH(3):CALL PUSH(5)

 

=={{header|J}}==

push=: monad def '0$stack=:stack,y'

pop=: monad def 'r[ stack=:}:stack[ r=.{:stack'

Example use:

 

pop ''

9

empty ''

pop and empty ignore their arguments. In this implementation. push returns an empty list.

 

=={{header|Java}}==

The collections framework includes a Stack class. Let's test it:

 

public class StackTest {

stack.pop();

}

{{out}}

<pre>New stack empty? true

 

Alternatively, you might implement a stack yourself...

private Node first = null;

public boolean isEmpty(){

}

}

{{works with|Java|1.5}}

private Node first = null;

public boolean isEmpty(){

}

}

 

=={{header|JavaScript}}==

The built-in Array class already has stack primitives.

stack.push(1)

stack.push(2,3);

print(stack.pop()); // 3

Here's a constructor that wraps the array:

this.data = new Array();

 

this.empty = function() {return this.data.length == 0}

this.peek = function() {return this.data[this.data.length - 1]}

Here's an example using the revealing module pattern instead of prototypes.

function makeStack() {

var stack = [];

};

}

 

=={{header|Jsish}}==

From Javascript entry. Being ECMAScript, Jsi supports stack primitives as part of the Array methods.

var stack = [];

puts('depth:', stack.length);

if (stack.length) printf('not '); printf('empty\n');

 

 

{{out}}

empty

depth: 0</pre>

 

=={{header|Julia}}==

 

The built-in <code>Array</code> class already has efficient (linear amortized time) stack primitives.

@show push!(stack, 1) # [1]

@show push!(stack, 2) # [1, 2]

@show length(stack) # 2

@show empty!(stack) # []

 

=={{header|K}}==

push:{stack::x,stack}

pop:{r:*stack;stack::1_ stack;r}

empty[]

1

 

=={{header|Kotlin}}==

Rather than use the java.util.Stack<E> class, we will write our own simple Stack<E> class for this task:

 

class Stack<E> {

println(e.message)

}

 

{{out}}

Can't pop elements from an empty stack

</pre>

 

=={{header|lang5}}==

: empty? dup execute length if 0 else -1 then swap drop ;

: pop dup execute length 1 - extract swap drop ;

pop . s. cr # 2 [ 1 ]

pop drop

 

=={{header|Lasso}}==

Lasso Arrays natively supports push and pop.

 

 

#a->push('a')

#a->pop // b

#a->pop // a

 

=={{header|Liberty BASIC}}==

global stack$

stack$=""

empty =(stack$="")

end function

 

=={{header|Lingo}}==

 

property _tos

on empty (me)

return voidP(me.peek())

 

=={{header|Logo}}==

[[UCB Logo]] has built-in methods for treating lists as stacks. Since they are destructive, they take the name of the stack rather than the list itself.

push "stack 1

push "stack 2

push "stack 3

print pop "stack ; 3

 

=={{header|Logtalk}}==

A stack can be trivially represented using the built-in representation for lists:

:- object(stack).

 

 

:- end_object.

 

=={{header|LOLCODE}}==

{{trans|UNIX Shell}}

HOW IZ I Init YR Stak

Stak HAS A Length ITZ 0

IM OUTTA YR Loop

 

 

{{Out}}

=={{header|Lua}}==

Tables have stack primitives by default:

table.insert(stack,3)

 

=={{header|M2000 Interpreter}}==

A Stack object can be used as LIFO or FIFO. Push statement push to top of stack. Read pop a value to a variable from top of stack. StackItem(1) read top item without modified stack. Data statement append items to bottom.

Module Checkit {

a=Stack

}

Checkit

 

Every module and function has a "current" stack. Number is a read only variable, which pop a value from current stack (or raise error if not number is in top of stack).

Return/Execution stack is hidden and different from stack of values.

 

Module Checkit {

Read a, b

Print alfa(1,2,3,4)=2.5

 

 

=={{header|Maple}}==

 

s := stack:-new(a, b):

empty(s);

pop(s);

{{out}}

<pre> c

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

SetAttributes[Push, HoldAll];[a_, elem_] := AppendTo[a, elem]

SetAttributes[Pop, HoldAllComplete];

->4

Peek[stack]

 

=={{header|MATLAB}} / {{header|Octave}}==

Here is a simple implementation of a stack, that works in Matlab and Octave. It is closely related to the queue/fifo example.

% push

 

% empty

Below is another solution, that encapsulates the fifo within the object-orientated "class" elements supported by Matlab. The given implementation is exactly the same as the MATLAB FIFO example, except that the "push()" function is modified to add stuff to the end of the queue instead of the beginning. This is a naive implementation, for rigorous applications this should be modified to initialize the LIFO to a buffered size, so that the "pop()" and "push()" functions don't resize the cell array that stores the LIFO's elements, every time they are called.

 

To use this implementation you must save this code in a MATLAB script file named "LIFOQueue.m" which must be saved in a folder named @LIFOQueue in your MATLAB directory.

classdef LIFOQueue

end %methods

Sample Usage:

myLIFO =

ans =

 

 

=={{header|Maxima}}==

 

load(basic)$

 

emptyp(a);

 

=={{header|Mercury}}==

Efficient, generic stacks are provided as part of the standard library in Mercury. For sake of illustration, here is how a simple stack could be implemented.

 

 

:- interface.

!:Stack = sstack(Elems).

 

 

It should be noted that this is purely an illustrative example of a very simple stack.

 

Note also that while pop/3 has three parameters, the function implementation looks like it has two. This is because the !Stack "parameter" is actually a ''pair'' of parameters using Mercury's state variable notation. !Stack is, in effect, two variables: !.Stack and !:Stack, input and output respectively. Using state variable notation here is a bit of overkill but again was brought in for pedagogical reasons to show the syntax.

 

=={{header|MiniScript}}==

// and any other number is true.

// therefore the .len function works as the inverse of a .empty function

else

print "Stack is empty"

{{out}}

<pre>

 

=={{header|Nanoquery}}==

declare internalList

 

return len(internalList) = 0

end

 

=={{header|Nemerle}}==

Mutable stacks are available in <tt>System.Collections</tt>, <tt>System.Collections.Generic</tt> and <tt>Nemerle.Collections</tt> depending on what functionality beyond the basics you want. An immutable stack could be implemented fairly easily, as, for example, this quick and dirty list based implementation.

{

private stack : list[T];

stack.Length == 0

}

 

=={{header|NetRexx}}==

* 13.08.2013 Walter Pachl translated from REXX version 2

**********************************************************************/

 

method empty(stk) static

{{out}}

<pre>

If we want a stack type limited to the four or five functions of the task, it is possible to define a distinct generic type <code>Stack[T]</code> derived from <code>seq[T]</code>. The code will be typically as follows. Note that we have defined a procedure <code>top</code> to get the value of the top item, another <code>mtop</code> to get a mutable reference to the top item and also a procedure <code>mtop=</code> to assign directly a value to the top item.

 

 

func initStack[T](initialSize = 32): Stack[T] =

echo s.top

s.mtop = 5

 

{{out}}

=={{header|Oberon-2}}==

{{Works with|oo2c version 2}}

MODULE Stacks;

IMPORT

Test

END Stacks.

{{out}}

<pre>

</pre>

{{works with|AOS}}

MODULE Stacks; (** AUTHOR ""; PURPOSE ""; *)

 

END Test;

END Stacks.

{{out}}

<pre>

=={{header|Objeck}}==

Class library support for Stack/IntStack/FloatStack

stack->Push(13);

stack->Push(7);

(stack->Pop() + stack->Pop())->PrintLine();

 

=={{header|Objective-C}}==

Using a NSMutableArray:

 

[stack addObject:value]; // pushing

[stack removeLastObject]; // popping

 

 

=={{header|OCaml}}==

Implemented as a singly-linked list, wrapped in an object:

 

class ['a] stack =

method is_empty =

lst = []

 

=={{header|Oforth}}==

Stack is already defined at startup.

 

Stack method: push self add ;

Stack method: pop self removeLast ;

 

Usage :

| s |

Stack new ->s

s pop println

s pop println

 

{{out}}

=={{header|Ol}}==

Simplest stack can be implemented using 'cons' and 'uncons' primitives.

(define stack #null)

(print "stack is: " stack)

(print "stack: " stack)

(print "is stack empty: " (eq? stack #null))

{{out}}

<pre>

But in real programs may be useful a more complex stack implementation based on coroutines (ol is a purely functional lisp, so it does not support mutators like 'set!').

 

(fork-server 'stack (lambda ()

(let this ((me '()))

(loop))))

(print "done.")

 

{{out}}

=={{header|ooRexx}}==

The ooRexx queue class functions as a stack as well (it is a dequeue really).

stack = .queue~of(123, 234) -- creates a stack with a couple of items

stack~push("Abc") -- pushing

-- the is empty test

if stack~isEmpty then say "The stack is empty"

 

=={{header|OxygenBasic}}==

The real stack is freely available!

function f()

sys a=1,b=2,c=3,d=4

 

f

 

=={{header|Oz}}==

A thread-safe, list-based stack. Implemented as a module:

export

New

@Stack == nil

end

There is also a stack implementation in the [http://www.mozart-oz.org/home/doc/mozart-stdlib/adt/stack.html standard library].

 

=={{header|PARI/GP}}==

pop()={

if(#v,

error("Stack underflow")

)

 

=={{header|Pascal}}==

This implements stacks of integers in standard Pascal (should work on all existing Pascal dialects).

type

pStackNode = ^tStackNode;

PopFromStack := node^.data;

dispose(node);

 

=={{header|Perl}}==

Perl comes prepared to treat its arrays as stacks, giving us the push and pop functions for free. To add empty, we basically give a new name to "not":

 

=={{header|Phix}}==

 

=={{header|PHP}}==

PHP arrays behave like a stack:

 

empty( $stack ); // true

 

echo array_pop( $stack ); // outputs "2"

 

=={{header|PicoLisp}}==

The built-in functions [http://software-lab.de/doc/refP.html#push push] and

[http://software-lab.de/doc/refP.html#pop pop] are used to maintain a stack (of any type).

(push 'Stack 2)

<pre>: Stack

-> (1 2 3)

other things contains a stack.

 

object s = ADT.Stack();

s->push("a");

s->top(), s->pop(), s->pop());

s->reset(); // Empty the stack

{{Out}}

<pre>

 

=={{header|PL/I}}==

 

declare s float controlled;

free s;

end;

 

=={{header|PostScript}}==

{{libheader|initlib}}

/push {exch cons}.

/pop {uncons exch pop}.

=false

[] empty?

 

=={{header|PowerShell}}==

A new stack:

$stack = New-Object -TypeName System.Collections.Stack

# or

$stack = [System.Collections.Stack] @()

Push some stuff on the stack:

1, 2, 3, 4 | ForEach-Object {$stack.Push($_)}

Show stack as a string:

$stack -join ", "

{{Out}}

<pre>

</pre>

Pop the top level of the stack:

$stack.Pop()

{{Out}}

<pre>

</pre>

Show stack as a string:

$stack -join ", "

{{Out}}

<pre>

</pre>

Get a copy of the top level of the stack:

$stack.Peek()

{{Out}}

<pre>

</pre>

The stack:

$stack

{{Out}}

<pre>

=={{header|Prolog}}==

Prolog is a particularly silly language to implement stack functions in, as the built-in lists can be treated as stacks in an ad hoc manner. Nonetheless, in the name of completeness:

% True if NEW is [ELEMENT|STACK]

push(ELEMENT,STACK,[ELEMENT|STACK]).

% empty( STACK )

% True if STACK is empty

 

=={{header|PureBasic}}==

For LIFO function PureBasic normally uses linked lists.

Usage as described above could look like;

 

Procedure Push_LIFO(n)

While Not Empty_LIFO()

Debug Pop_LIFO()

 

{{out}}

The faster and Pythonic way is using a deque (available from 2.4).

A regular list is a little slower.

stack = deque()

stack.append(value) # pushing

value = stack.pop()

If you need to expose your stack to the world, you may want to create a simpler wrapper:

 

class Stack:

return self._items.pop()

def __nonzero__(self):

Here is a stack implemented as linked list - with the same list interface.

def __init__(self):

self._first = None

raise IndexError, "pop from empty stack"

value, self._first = self._first

Notes:

 

Using list interface - append, __nonzero__ make it easier to use, cleanup the client code, and allow changing the implementation later without affecting the client code.

For example, instead of:

You can write:

Quick testing show that deque is about 5 times faster then the wrapper linked list implementations. This may be important if your stack is used in tight loops.

 

Quackery is a stack based language. In addition to ''the stack'' (i.e. the Quackery data stack) and the call stack, named ancillary stacks can be created with <code>[ stack ] is <name-of-stack></code>. Pushing to and popping from ancillary stacks is done with the words <code>put</code> and <code>take</code>. A word to test if an ancillary stack is empty can be defined as <code>[ size 1 = ] is isempty</code>. (The word <code>empty</code> already has a meaning in Quackery.) The word <code>share</code> returns the topmost element of an ancillary stack without changing the ancillary stack. Other ancillary stack operations are also available.

 

 

[ stack ] is mystack ( --> s )

mystack take echo say " has been removed from mystack" cr cr

mystack isempty if [ say "mystack is empty" cr cr ]

 

{{out}}

{{libheader|proto}}

See [[FIFO]] for functional and object oriented implementations of a First-In-First-Out object, with similar code.

 

stack <- proto(expr = {

stack$pop()

# Error in get("pop", env = stack, inherits = TRUE)(stack, ...) :

 

=={{header|Racket}}==

Quick functional version:

 

#lang racket

(define stack '())

(define (pop stack) (values (car stack) (cdr stack)))

(define (empty? stack) (null? stack))

 

And a destructive object:

 

(struct stack ([items #:auto]) #:mutable #:auto-value '())

(define (push! x stack)

(define (empty? stack)

(null? (stack-items stack)))

 

=={{header|Raku}}==

 

Raku still has the stack functions from Perl 5, but now they also can be accessed by object notation:

@stack.push($elem); # add $elem to the end of @stack

$elem = @stack.pop; # get the last element back

@stack.elems == 0 # true, because the stack is empty

 

=={{header|Raven}}==

Use built in ''stack'' type:

1 s push

Word ''empty'' is also built in:

 

=={{header|REBOL}}==

Title: "Stack"

URL: http://rosettacode.org/wiki/Stack

assert ['test = v/pop]

assert ['a = v/pop]

Sample run:

<pre>Simple integers:

 

=={{header|Retro}}==

: push ( na- ) dup ++ dup @ + ! ;

: pop ( a-n ) dup @ over -- + @ ;

st top putn

st pop putn st pop putn st pop putn

 

=={{header|REXX}}==

===version 1===

push y /*pushes 123 onto the stack. */

pull g /*pops last value stacked & removes it. */

exit /*stick a fork in it, we're done. */

 

 

===version 2===

* supports push, pull, and peek

* 11.08.2013 Walter Pachl

 

empty: Procedure Expose stk.

{{out}}

<pre>

 

=={{header|Ring}}==

# Project : Stack

 

see "Pop: stack is empty" + nl

ok

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

Using an Array, there are already methods Array#push, Array#pop and Array#empty?.

stack.push(value) # pushing

value = stack.pop # popping

If you need to expose your stack to the world, you may want to create a simpler wrapper. Here is a wrapper class ''Stack'' that wraps ''Array'' but only exposes stack methods.

 

# A stack contains elements in last-in, first-out order.

end

alias inspect to_s

 

p s.empty? # => true

p s.size # => 0

p s = Stack[:a, :b, :c] # => Stack[:a, :b, :c]

p s << :d # => Stack[:a, :b, :c, :d]

 

Just meeting the requirements of a push, pop and empty method:

 

class Stack

def_delegators :@stack, :push, :pop, :empty?

end

(push takes multiple arguments; pop takes an optional argument which specifies how many to pop)

 

=={{header|Run BASIC}}==

global stack$

global stackEnd

FUNCTION mt$()

stackEnd = 0

{{out}}

<pre>Pushed A stack has 1

One could just use a vector (<code>Vec<T></code>) which is part of the standard library

 

let mut stack = Vec::new();

stack.push("Element1");

assert_eq!(Some("Element1"), stack.pop());

assert_eq!(None, stack.pop());

 

===Simple implementation===

Simply uses a singly-linked list.

 

pub struct Stack<T> {

}

}

 

=={{header|Sather}}==

This one uses a builtin linked list to keep the values pushed onto the stack.

private attr stack :LLIST{T};

 

return stack.is_empty;

end;

 

main is

s ::= #STACK{INT};

until!(s.is_empty); end;

end;

Sather library has the abstract class <code>$STACK{T}</code>, but using this forces us to implement other methods too.

 

=={{header|Scala}}==

The Do it yourself approach:

private var items = List[T]()

 

 

def push(value: T) = items = value +: items

Or use the standard Scala library.

Slightly modified to meet to requirements of this task.

 

class Stack[T] extends Stak[T] {

}

def peek: T = this.head

 

val stack = new Stack[String]

assert(stack.pop() == "Peter Pan")

println("Completed without errors")

 

=={{header|Scheme}}==

This version uses primitive message passing.

(let ((st '()))

(lambda (message . args)

(set! st (cdr st))

result)))

 

=={{header|Seed7}}==

 

const func type: stack (in type: baseType) is func

writeln(pop(s) = 10);

writeln(empty(s));

 

=={{header|SenseTalk}}==

repeat with each item of 1 .. 10

push it into stack

pop stack

put it

 

=={{header|Sidef}}==

Using a built-in array:

stack.push(42); # pushing

say stack.pop; # popping

 

Creating a Stack class:

method pop { stack.pop };

method push(item) { stack.push(item) };

stack.push(42);

say stack.pop; # => 42

 

=={{header|Slate}}==

From Slate's standard library:

"An abstraction over ExtensibleArray implementations to follow the stack

protocol. The convention is that the Sequence indices run least-to-greatest

 

s@(Stack traits) bottom

 

=={{header|Smalltalk}}==

Smalltalk has a built-in Stack class, instances of which you can send messages:

s := Stack new.

s push: 1.

s pop.

s top. "2"

 

=={{header|Standard ML}}==

The signature for a module supplying a stack interface, with a couple added functions.

 

sig

type 'a stack

val map : ('a -> 'b) -> 'a stack -> 'b stack

val app : ('a -> unit) -> 'a stack -> unit

 

An implementation of the <code>STACK</code> signature, using immutable lists.

 

struct

type 'a stack = 'a list

fun map f st = List.map f st

fun app f st = List.app f st

 

=={{header|Stata}}==

=={{header|Swift}}==

Generic stack.

var items = [T]()

var empty:Bool {

println(stack.peek())

stack.pop()

{{out}}

<pre>

 

=={{header|Tailspin}}==

processor Stack

@: $;

' -> !OUT::write

'$myStack::empty;' -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

Here's a simple implementation using a list:

upvar 1 $stackvar stack

lappend stack $value

peek S ;# ==> bar

pop S ;# ==> bar

{{tcllib|struct::stack}}

struct::stack S

S size ;# ==> 0

S peek ;# ==> d

S pop 4 ;# ==> d c b a

 

=={{header|UnixPipes}}==

push() { echo $1 >> stack; }

pop() {

}

empty() { head -n -1 stack |wc -l; }

test it:

% pop;pop;pop;pop

them

us

you

 

=={{header|UNIX Shell}}==

 

Here's a simple single-stack solution:

if [[ -n $KSH_VERSION ]]; then

set -A stack

while ! empty; do

pop

 

{{Out}}

You can generalize it to multiple stacks with some judicious use of the twin evils of pass-by-name and <tt>eval</tt>:

 

if [[ -n $KSH_VERSION ]]; then

eval 'set -A '"$1"

while ! empty mystack; do

pop mystack

 

{{Out}}

=={{header|VBA}}==

Define a class Stack in a class module with that name.

 

'uses a dynamic array of Variants to stack the values

Property Get Size() As Integer

Size = myStackHeight

Usage example:

Public Sub stacktest()

Dim aStack As New Stack

.Pop

End With

{{out}}

<pre>

=={{header|VBScript}}==

===Stack class===

dim tos

dim stack()

wscript.echo s.pop

if s.stackempty then exit for

{{out}} (changes every time)

<pre>-1

0.7055475</pre>

===Using an ArrayList.===

Option Explicit

Function empty_(s)

empty_ = s.Count = 0

{{out}}

<pre>

</pre>

 

max_depth = 256

)

stack.pop() or { return }

}

{{out}}

<pre>Stack is empty? Yes

Stacks as user-defined objects backed by a list.

 

(tag 'stack nil)

 

 

def (empty? s) :case (isa stack s)

 

Example usage:

{{libheader|Wren-seq}}

This uses the Stack class in the above module.

 

var s = Stack.new()

s.clear()

System.print("Stack cleared")

 

{{out}}

 

=={{header|X86 Assembly}}==

; x86_64 linux nasm

 

mov rdi, 1

syscall

 

=={{header|XLISP}}==

This is a fairly straightforward implementation, representing a stack as a linked list inside an object.

(instance-variables vals))

 

 

(define-method (stack 'emptyp)

A sample REPL session:

[1] (define st (stack 'new))

 

 

#T

 

=={{header|XPL0}}==

int Stack(100), SP;

 

while not Empty do [IntOut(0, Pop); ChOut(0, ^ )];

CrLf(0);

 

{{out}}

 

=={{header|Yabasic}}==

dim stack(limit)

 

 

print "Pop ", pop()

=={{header|Z80 Assembly}}==

 

 

 

 

push bc

push de

 

Popping is very similar. To properly pop values, they must be popped in the reverse order they were pushed.

pop de

pop bc

 

The stack is empty if its value equals the original starting value of the stack pointer. This is a little difficult, since the stack doesn't necessarily start in a fixed location like it does on the 6502. There are two ways to do this:

 

 

 

From there it's a matter of comparing this value to the current stack pointer, which in itself is tricky since the built-in compare instruction forces you to use the accumulator as one of the operands, and works natively in terms of 8-bit values.

 

On the Game Boy, the stack can also be manually adjusted by a signed 8-bit constant. A Zilog Z80 cannot do this in a single command. The code below only works on a Game Boy or any other hardware running on a Sharp LR35902 CPU:

 

=={{header|zkl}}==

Lists have stack methods so this class is somewhat reduntant

var [const] stack=L();

fcn push(x){stack.append(x); self}

fcn empty {(not stack.len())}

var [proxy] isEmpty = empty;

{{out}}

<pre>