Sync

Task/Stack/00DESCRIPTION

@@ -12,3 +12,5 @@ Sometimes the last pushed stack element is made accessible for immutable access
 Stacks allow a very simple hardware implementation. They are common in almost all processors. In programming stacks are also very popular for their way ('''LIFO''') of resource management, usually memory. Nested scopes of language objects are naturally implemented by a stack (sometimes by multiple stacks). This is a classical way to implement local variables of a reentrant or recursive subprogram. Stacks are also used to describe a formal computational framework. See [[wp:Stack_automaton|stack machine]]. Many algorithms in pattern matching, compiler construction (e.g. [[wp:Recursive_descent|recursive descent parsers]]), and machine learning (e.g. based on [[wp:Tree_traversal|tree traversal]]) have a natural representation in terms of stacks.
 
 Create a stack supporting the basic operations: push, pop, empty.
+
+{{Template:See also lists}}

Task/Stack/ALGOL-68/stack-1.alg

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*- #
+CO REQUIRES:
+  MODE OBJVALUE = ~ # Mode/type of actual obj to be stacked #
+END CO
+
+MODE OBJNEXTLINK = STRUCT(
+  REF OBJNEXTLINK next,
+  OBJVALUE value # ... etc. required #
+);
+
+PROC obj nextlink new = REF OBJNEXTLINK:
+  HEAP OBJNEXTLINK;
+
+PROC obj nextlink free = (REF OBJNEXTLINK free)VOID:
+  next OF free := obj stack empty # give the garbage collector a BIG hint #

Task/Stack/ALGOL-68/stack-2.alg

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*- #
+CO REQUIRES:
+  MODE OBJNEXTLINK = STRUCT(
+    REF OBJNEXTLINK next,
+    OBJVALUE value
+  );
+  PROC obj nextlink new = REF OBJNEXTLINK: ~,
+  PROC obj nextlink free = (REF OBJNEXTLINK free)VOID: ~
+END CO
+
+# actually a pointer to the last LINK, there ITEMs are ADDED, pushed & popped #
+MODE OBJSTACK = REF OBJNEXTLINK;
+
+OBJSTACK obj stack empty = NIL;
+
+BOOL obj stack par = FALSE; # make code thread safe #
+SEMA obj stack sema = LEVEL ABS obj stack par;
+# Warning: 1 SEMA for all stacks of type obj, i.e. not 1 SEMA per stack #
+
+PROC obj stack init = (REF OBJSTACK self)REF OBJSTACK:
+  self := obj stack empty;
+
+# see if the program/coder wants the OBJ problem mended... #
+PROC (REF OBJSTACK #self#)BOOL obj stack index error mended
+  := (REF OBJSTACK self)BOOL: (abend("obj stack index error"); stop);
+
+PROC on obj stack index error = (REF OBJSTACK self, PROC(REF OBJSTACK #self#)BOOL mended)VOID:
+  obj stack index error mended := mended;
+
+PROC obj stack push = (REF OBJSTACK self, OBJVALUE obj)REF OBJSTACK:(
+  IF obj stack par THEN DOWN obj stack sema FI;
+  self := obj nextlink new := (self, obj);
+  IF obj stack par THEN UP obj stack sema FI;
+  self
+);
+
+# aliases: define a useful put (+=:) operator... #
+OP +=: = (OBJVALUE obj, REF OBJSTACK self)REF OBJSTACK: obj stack push(self, obj);
+
+PROC obj stack pop = (REF OBJSTACK self)OBJVALUE: (
+# DOWN obj stack sema; #
+  IF self IS obj stack empty THEN
+    IF NOT obj stack index error mended(self) THEN abend("obj stack index error") FI FI;
+
+  OBJNEXTLINK old head := self;
+  OBJSTACK new head := next OF self;
+  OBJVALUE out := value OF old head;
+  obj nextlink free(old head); # freeing nextlink, NOT queue! #
+  self := new head;
+#;UP obj stack sema; #
+  out
+);
+
+PROC obj stack is empty = (REF OBJSTACK self)BOOL:
+  self IS obj stack empty;
+
+SKIP

Task/Stack/ALGOL-68/stack-3.alg

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*- #
+MODE DIETITEM = STRUCT(
+  STRING food, annual quantity, units, REAL cost
+);
+
+# Stigler's 1939 Diet ... #
+FORMAT diet item fmt = $g": "g" "g" = $"zd.dd$;
+[]DIETITEM stigler diet = (
+  ("Cabbage",           "111","lb.",  4.11),
+  ("Dried Navy Beans",  "285","lb.", 16.80),
+  ("Evaporated Milk",    "57","cans", 3.84),
+  ("Spinach",            "23","lb.",  1.85),
+  ("Wheat Flour",       "370","lb.", 13.33),
+  ("Total Annual Cost",    "","",    39.93)
+)

Task/Stack/ALGOL-68/stack-4.alg

@@ -0,0 +1,20 @@
+#!/usr/bin/a68g --script #
+# -*- coding: utf-8 -*- #
+
+MODE OBJVALUE = DIETITEM;
+PR read "prelude/next_link.a68" PR;
+PR read "prelude/stack_base.a68" PR;
+
+PR read "test/data_stigler_diet.a68" PR;
+OBJSTACK example stack; obj stack init(example stack);
+
+FOR i TO UPB stigler diet DO
+#  obj stack push(example stack, stigler diet[i]) #
+  stigler diet[i] +=: example stack
+OD;
+
+printf($"Items popped in reverse:"l$);
+WHILE NOT obj stack is empty(example stack) DO
+# OR example stack ISNT obj stack empty #
+  printf((diet item fmt, obj stack pop(example stack), $l$))
+OD

Task/Stack/Component-Pascal/stack.component

@@ -0,0 +1,110 @@
+MODULE Stacks;
+IMPORT StdLog;
+
+TYPE
+	(* some pointers to records *)
+	Object* = POINTER TO ABSTRACT RECORD END;
+	
+	Integer = POINTER TO RECORD (Object)
+		i: INTEGER
+	END;
+	
+	Point = POINTER TO RECORD (Object)
+		x,y: REAL
+	END;
+
+	Node = POINTER TO LIMITED RECORD
+		next- : Node;
+		data-: ANYPTR;
+	END;
+
+	(* Stack *)
+	Stack* = POINTER TO RECORD
+		top- : Node;
+	END;
+	
+	PROCEDURE (dn: Object) Show*, NEW, ABSTRACT;
+	
+	PROCEDURE (i: Integer) Show*;
+	BEGIN
+		StdLog.String("Integer(");StdLog.Int(i.i);StdLog.String(");");StdLog.Ln
+	END Show;
+	
+	PROCEDURE (p: Point) Show*;
+	BEGIN
+		StdLog.String("Point(");StdLog.Real(p.x);StdLog.Char(',');
+		StdLog.Real(p.y);StdLog.String(");");StdLog.Ln
+	END Show;
+	
+	PROCEDURE (s: Stack) Init, NEW;
+	BEGIN
+		s.top := NIL;
+	END Init;
+	
+	PROCEDURE (s: Stack) Push*(data: ANYPTR), NEW;
+	VAR
+		n: Node;
+	BEGIN
+		NEW(n);n.next := NIL;n.data := data;
+		IF s.top = NIL THEN
+			s.top := n
+		ELSE
+			n.next := s.top;
+			s.top := n
+		END
+	END Push;
+	
+	PROCEDURE (s: Stack) Pop*(): ANYPTR, NEW;
+	VAR
+		x: ANYPTR;
+	BEGIN
+		IF s.top # NIL THEN
+			x := s.top.data;
+			s.top := s.top.next
+		ELSE
+			x := NIL
+		END;
+		RETURN x
+	END Pop;
+	
+	PROCEDURE (s: Stack) Empty*(): BOOLEAN, NEW;
+	BEGIN
+		RETURN s.top = NIL
+	END Empty;
+	
+	PROCEDURE NewStack*(): Stack;
+	VAR
+		s: Stack;
+	BEGIN
+		NEW(s);s.Init;
+		RETURN s
+	END NewStack;
+	
+	PROCEDURE NewInteger*(data: INTEGER): Integer;
+	VAR
+		i: Integer;
+	BEGIN
+		NEW(i);i.i := data;
+		RETURN i
+	END NewInteger;
+	
+	PROCEDURE NewPoint*(x,y: REAL): Point;
+	VAR
+		p: Point;
+	BEGIN
+		NEW(p);p.x := x;p.y := y;
+		RETURN p
+	END NewPoint;
+	
+	PROCEDURE TestStack*;
+	VAR
+		s: Stack;
+	BEGIN
+		s := NewStack();
+		s.Push(NewInteger(1));
+		s.Push(NewPoint(2.0,3.4));
+		s.Pop()(Object).Show();
+		s.Pop()(Object).Show();
+	END TestStack;
+	
+END Stacks.

Task/Stack/Eiffel/stack.e

@@ -0,0 +1,43 @@
+class
+	STACK_ON_ARRAY
+
+create
+	make
+
+feature -- Implementation
+
+	empty: BOOLEAN
+		do
+			Result := stack.is_empty
+		ensure
+			empty: Result = (stack.count = 0)
+		end
+
+	push (item: ANY)
+		do
+			stack.force (item, stack.count)
+		ensure
+			pushed: stack [stack.upper] = item
+			growth: stack.count = old stack.count + 1
+		end
+
+	pop: ANY
+		require
+			not_empty: not empty
+		do
+			Result := stack.at (stack.upper)
+			stack.remove_tail (1)
+		ensure
+			reduction: stack.count = old stack.count - 1
+		end
+
+feature {NONE} -- Initialization
+
+	stack: ARRAY [ANY]
+
+	make
+		do
+			create stack.make_empty
+		end
+
+end

Task/Stack/Logtalk/stack.logtalk

@@ -0,0 +1,12 @@
+:- object(stack).
+
+    :- public(push/3).
+    push(Element, Stack, [Element| Stack]).
+
+    :- public(pop/3).
+    pop([Top| Stack], Top, Stack).
+
+    :- public(empty/1)
+    empty([]).
+
+:- end_object.

Task/Stack/Mercury/stack.mercury

@@ -0,0 +1,33 @@
+:- module sstack.
+
+:- interface.
+
+% We're going to call the type sstack (simple stack) because we don't want to get it
+% accidentally confused with the official stack module in the standard library.
+:- type sstack(T).
+
+:- func sstack.new = sstack(T).
+:- pred sstack.is_empty(sstack(T)::in) is semidet.
+:- func sstack.push(sstack(T), T) = sstack(T).
+:- pred sstack.pop(T::out, sstack(T)::in, sstack(T)::out) is semidet.
+
+:- implementation.
+
+:- import_module list.
+
+:- type sstack(T)
+   --->  sstack(list(T)).
+
+sstack.new = sstack([]).
+
+sstack.is_empty(sstack([])).
+
+sstack.push(Stack0, Elem) = Stack1 :-
+   Stack0 = sstack(Elems),
+   Stack1 = sstack([Elem | Elems]).
+
+sstack.pop(Elem, !Stack) :-
+   !.Stack = sstack([Elem | Elems]),
+   !:Stack = sstack(Elems).
+
+:- end_module sstack.

Task/Stack/Nemerle/stack.nemerle

@@ -0,0 +1,34 @@
+public class Stack[T]
+{
+    private stack : list[T];
+
+    public this()
+    {
+        stack = [];
+    }
+
+    public this(init : list[T])
+    {
+        stack = init;
+    }
+
+    public Push(item : T) : Stack[T]
+    {
+        Stack(item::stack)
+    }
+
+    public Pop() : T * Stack[T]
+    {
+        (stack.Head, Stack(stack.Tail))
+    }
+
+    public Peek() : T
+    {
+        stack.Head
+    }
+
+    public IsEmpty() : bool
+    {
+        stack.Length == 0
+    }
+}

Task/Stack/NetRexx/stack.netrexx

@@ -0,0 +1,42 @@
+/* NetRexx ************************************************************
+* 13.08.2013 Walter Pachl  translated from REXX version 2
+**********************************************************************/
+options replace format comments java crossref savelog symbols nobinary
+
+stk = create_stk
+
+say push(stk,123) 'from push'
+say empty(stk)
+say peek(stk)     'from peek'
+say pull(stk)     'from pull'
+say empty(stk)
+Say pull(stk)     'from pull'
+
+method create_stk static returns Rexx
+  stk = ''
+  stk[0] = 0
+  return stk
+
+method push(stk,v) static
+  stk[0]=stk[0]+1
+  stk[stk[0]]=v
+  Return v
+
+method peek(stk) static
+  x=stk[0]
+  If x=0 Then
+    Return 'stk is empty'
+  Else
+    Return stk[x]
+
+method pull(stk) static
+  x=stk[0]
+  If x=0 Then
+    Return 'stk is empty'
+  Else Do
+    stk[0]=stk[0]-1
+    Return stk[x]
+    End
+
+method empty(stk) static
+  Return stk[0]=0

Task/Stack/REXX/stack-1.rexx

@@ -0,0 +1,7 @@
+y=123                        /*define a REXX variable, value is 123  */
+push y                       /*pushes   123   onto the stack.        */
+pull g                       /*pops last value stacked & removes it. */
+q=empty()                    /*invokes the  EMPTY  subroutine (below)*/
+exit                         /*stick a fork in it, we're done.       */
+
+empty: return queued()       /*subroutine returns # of stacked items.*/

Task/Stack/REXX/stack-2.rexx

@@ -0,0 +1,42 @@
+/* REXX ***************************************************************
+* supports push, pull, and peek
+* 11.08.2013 Walter Pachl
+**********************************************************************/
+stk.=0
+Call push 123
+Say empty()
+say peek()
+say pull()
+Say empty()
+say peek()
+say push(456)
+say peek()
+Exit
+
+push: Procedure Expose stk.
+  Parse Arg v
+  z=stk.0+1
+  stk.z=v
+  stk.0=z
+  Return v
+
+peek: Procedure Expose stk.
+  If stk.0=0 Then
+    Return 'stack is empty'
+  Else Do
+    z=stk.0
+    Return stk.z
+    End
+
+pull: Procedure Expose stk.
+  If stk.0=0 Then
+    Return 'stack is empty'
+  Else Do
+    z=stk.0
+    res=stk.z
+    stk.0=stk.0-1
+    Return res
+    End
+
+empty: Procedure Expose stk.
+  Return stk.0=0

Task/Stack/Scala/stack-1.scala

@@ -0,0 +1,17 @@
+class Stack[T] {
+  private var items = List[T]()
+
+  def isEmpty = items.isEmpty
+
+  def peek = items match {
+    case List()       => error("Stack empty")
+    case head :: rest => head
+  }
+
+  def pop = items match {
+    case List()       => error("Stack empty")
+    case head :: rest => items = rest; head
+  }
+
+  def push(value: T) = items = value +: items
+}

Task/Stack/Scala/stack-2.scala

@@ -0,0 +1,9 @@
+import collection.mutable.{ Stack => Stak }
+
+class Stack[T] extends Stak[T] {
+  override def pop: T = {
+    if (this.length == 0) error("Can't Pop from an empty Stack.")
+    else super.pop
+  }
+  def peek: T = this.head
+}

Task/Stack/Scala/stack-3.scala

@@ -0,0 +1,13 @@
+object StackTest extends App {
+
+  val stack = new Stack[String]
+
+  stack.push("Peter Pan")
+  stack.push("Suske & Wiske", "Alice in Wonderland")
+
+  assert(stack.peek == "Alice in Wonderland")
+  assert(stack.pop() == "Alice in Wonderland")
+  assert(stack.pop() == "Suske & Wiske")
+  assert(stack.pop() == "Peter Pan")
+  println("Completed without errors")
+}