Data update

Task/Stack/Ada/stack-1.adb

@@ -0,0 +1,16 @@
+generic
+   type Element_Type is private;
+package Generic_Stack is
+   type Stack is private;
+   procedure Push (Item : Element_Type; Onto : in out Stack);
+   procedure Pop (Item : out Element_Type; From : in out Stack);
+   function Create return Stack;
+   Stack_Empty_Error : exception;
+private
+   type Node;
+   type Stack is access Node;
+   type Node is record
+      Element : Element_Type;
+      Next    : Stack        := null;
+   end record;
+end Generic_Stack;

Task/Stack/Ada/stack-2.adb

@@ -0,0 +1,42 @@
+with Ada.Unchecked_Deallocation;
+
+package body Generic_Stack is
+
+   ------------
+   -- Create --
+   ------------
+
+   function Create return Stack is
+   begin
+      return (null);
+   end Create;
+
+   ----------
+   -- Push --
+   ----------
+
+   procedure Push(Item : Element_Type; Onto : in out Stack) is
+      Temp : Stack := new Node;
+   begin
+      Temp.Element := Item;
+      Temp.Next := Onto;
+      Onto := Temp;
+   end Push;
+
+   ---------
+   -- Pop --
+   ---------
+
+   procedure Pop(Item : out Element_Type; From : in out Stack) is
+      procedure Free is new Ada.Unchecked_Deallocation(Node, Stack);
+      Temp : Stack := From;
+   begin
+      if Temp = null then
+         raise Stack_Empty_Error;
+      end if;
+      Item := Temp.Element;
+      From := Temp.Next;
+      Free(Temp);
+   end Pop;
+
+end Generic_Stack;

Task/Stack/ArkScript/stack.ark

@@ -0,0 +1,26 @@
+(let stack (fun () {
+  (mut data [])
+
+  (let push (fun (value) (set data (concat [value] data))))
+  (let popTop (fun () {
+    (let res (head data))
+    (pop! data 0)
+    res }))
+  (let isEmpty? (fun () (empty? data)))
+
+  (fun (&data &push &popTop &isEmpty?) ()) }))
+
+(let myStack (stack))
+(myStack.push 1)
+(myStack.push 2)
+(myStack.push 3)
+
+(print myStack.data)
+
+(print "top: " (myStack.popTop))
+(print myStack.data)
+
+(print "empty: " (myStack.isEmpty?))
+(myStack.popTop)
+(myStack.popTop)
+(print "empty: " (myStack.isEmpty?))

Task/Stack/Batch-File/stack-1.bat

@@ -0,0 +1,69 @@
+@echo off
+setlocal enableDelayedExpansion
+
+:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+:: LIFO stack usage
+
+:: Define the stack
+call :newStack myStack
+
+:: Push some values onto the stack
+for %%A in (value1 value2 value3) do call :pushStack myStack %%A
+
+:: Test if stack is empty by examining the top "attribute"
+if myStack.top==0 (echo myStack is empty) else (echo myStack is NOT empty)
+
+:: Peek at the top stack value
+call:peekStack myStack val && echo a peek at the top of myStack shows !val!
+
+:: Pop the top stack value
+call :popStack myStack val && echo popped myStack value=!val!
+
+:: Push some more values onto the stack
+for %%A in (value4 value5 value6) do call :pushStack myStack %%A
+
+:: Process the remainder of the stack
+:processStack
+call :popStack myStack val || goto :stackEmpty
+echo popped myStack value=!val!
+goto :processStack
+:stackEmpty
+
+:: Test if stack is empty using the empty "method"/"macro". Use of the
+:: second IF statement serves to demonstrate the negation of the empty
+:: "method". A single IF could have been used with an ELSE clause instead.
+if %myStack.empty% echo myStack is empty
+if not %myStack.empty% echo myStack is NOT empty
+exit /b
+
+:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+:: LIFO stack definition
+
+:newStack stackName
+set /a %~1.top=0
+:: Define an empty "method" for this stack as a sort of macro
+set "%~1.empty=^!%~1.top^! == 0"
+exit /b
+
+:pushStack stackName value
+set /a %~1.top+=1
+set %~1.!%~1.top!=%2
+exit /b
+
+:popStack stackName returnVar
+:: Sets errorlevel to 0 if success
+:: Sets errorlevel to 1 if failure because stack was empty
+if !%~1.top! equ 0 exit /b 1
+for %%N in (!%~1.top!) do (
+  set %~2=!%~1.%%N!
+  set %~1.%%N=
+)
+set /a %~1.top-=1
+exit /b 0
+
+:peekStack stackName returnVar
+:: Sets errorlevel to 0 if success
+:: Sets errorlevel to 1 if failure because stack was empty
+if !%~1.top! equ 0 exit /b 1
+for %%N in (!%~1.top!) do set %~2=!%~1.%%N!
+exit /b 0

Task/Stack/Batch-File/stack-2.bat

@@ -0,0 +1,22 @@
+@echo off
+setlocal enabledelayedexpansion
+(set lf=^
+
+)
+(set stack=
+set stack.push=set "stack=#^!lf^!^!stack^!"
+set stack.pop=for %%l in ("^!lf^!"^) do set "stack=^!stack:*%%~l=^!"
+set stack.empty=(call;^&if defined stack call^)
+set stack.top=echo:^^!stack^^! ^| (set /p _=^& call echo:%%_%%^))
+:: ^ stack.top : https://stackoverflow.com/a/14965458
+%stack.push:#=1%
+%stack.push:#=2%
+%stack.top%
+for %%l in ("!lf!") do echo:"!stack:%%~l= !"
+%stack.pop%
+for %%l in ("!lf!") do echo:"!stack:%%~l= !"
+%stack.empty% && echo empty: true || echo empty: false
+%stack.pop%
+for %%l in ("!lf!") do echo:"!stack:%%~l= !"
+%stack.empty% && echo empty: true || echo empty: false
+goto:eof

Task/Stack/COBOL/stack-1.cob

@@ -0,0 +1,2 @@
+       01  stack.
+         05  head USAGE IS POINTER VALUE NULL.

Task/Stack/COBOL/stack-2.cob

@@ -0,0 +1,5 @@
+       01  node BASED.
+         COPY node-info REPLACING
+           01 BY 05
+           node-info BY info.
+         05  link USAGE IS POINTER VALUE NULL.

Task/Stack/COBOL/stack-3.cob

@@ -0,0 +1 @@
+       01  node-info PICTURE X(10) VALUE SPACES.

Task/Stack/COBOL/stack-4.cob

@@ -0,0 +1,3 @@
+       01  p PICTURE 9.
+         88 nil VALUE ZERO WHEN SET TO FALSE IS 1.
+         88 t   VALUE 1 WHEN SET TO FALSE IS ZERO.

Task/Stack/COBOL/stack-5.cob

@@ -0,0 +1,247 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. push.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node.
+       LINKAGE SECTION.
+       COPY stack.
+       01  node-info-any PICTURE X ANY LENGTH.
+       PROCEDURE DIVISION USING stack node-info-any.
+         ALLOCATE node
+         CALL "pointerp" USING
+           BY REFERENCE ADDRESS OF node
+           BY REFERENCE p
+         END-CALL
+         IF nil
+           CALL "stack-overflow-error" END-CALL
+         ELSE
+           MOVE node-info-any TO info OF node
+           SET link OF node TO head OF stack
+           SET head OF stack TO ADDRESS OF node
+         END-IF
+         GOBACK.
+       END PROGRAM push.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. pop.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY node-info.
+       PROCEDURE DIVISION USING stack node-info.
+         CALL "empty" USING
+           BY REFERENCE stack
+           BY REFERENCE p
+         END-CALL
+         IF t
+           CALL "stack-underflow-error" END-CALL
+         ELSE
+           SET ADDRESS OF node TO head OF stack
+           SET head OF stack TO link OF node
+           MOVE info OF node TO node-info
+         END-IF
+         FREE ADDRESS OF node
+         GOBACK.
+       END PROGRAM pop.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. empty.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY p.
+       PROCEDURE DIVISION USING stack p.
+         CALL "pointerp" USING
+           BY CONTENT head OF stack
+           BY REFERENCE p
+         END-CALL
+         IF t
+           SET t TO FALSE
+         ELSE
+           SET t TO TRUE
+         END-IF
+         GOBACK.
+       END PROGRAM empty.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. head.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY node-info.
+       PROCEDURE DIVISION USING stack node-info.
+         CALL "empty" USING
+           BY REFERENCE stack
+           BY REFERENCE p
+         END-CALL
+         IF t
+           CALL "stack-underflow-error" END-CALL
+         ELSE
+           SET ADDRESS OF node TO head OF stack
+           MOVE info OF node TO node-info
+         END-IF
+         GOBACK.
+       END PROGRAM head.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. peek.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY node-info.
+       PROCEDURE DIVISION USING stack node-info.
+         CALL "head" USING
+           BY CONTENT stack
+           BY REFERENCE node-info
+         END-CALL
+         GOBACK.
+       END PROGRAM peek.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. pointerp.
+       DATA DIVISION.
+       LINKAGE SECTION.
+       01  test-pointer USAGE IS POINTER.
+       COPY p.
+       PROCEDURE DIVISION USING test-pointer p.
+         IF test-pointer EQUAL NULL
+           SET nil TO TRUE
+         ELSE
+           SET t TO TRUE
+         END-IF
+         GOBACK.
+       END PROGRAM pointerp.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. stack-overflow-error.
+       PROCEDURE DIVISION.
+         DISPLAY "stack-overflow-error" END-DISPLAY
+         STOP RUN.
+       END PROGRAM stack-overflow-error.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. stack-underflow-error.
+       PROCEDURE DIVISION.
+         DISPLAY "stack-underflow-error" END-DISPLAY
+         STOP RUN.
+       END PROGRAM stack-underflow-error.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. copy-stack.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node-info.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY stack REPLACING stack BY new-stack.
+       PROCEDURE DIVISION USING stack new-stack.
+         CALL "empty" USING
+           BY REFERENCE stack
+           BY REFERENCE p
+         END-CALL
+         IF nil
+           CALL "pop" USING
+             BY REFERENCE stack
+             BY REFERENCE node-info
+           END-CALL
+           CALL "copy-stack" USING
+             BY REFERENCE stack
+             BY REFERENCE new-stack
+           END-CALL
+           CALL "push" USING
+             BY REFERENCE stack
+             BY REFERENCE node-info
+           END-CALL
+           CALL "push" USING
+             BY REFERENCE new-stack
+             BY REFERENCE node-info
+           END-CALL
+         END-IF
+         GOBACK.
+       END PROGRAM copy-stack.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. reverse-stack.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node-info.
+       LINKAGE SECTION.
+       COPY stack.
+       COPY stack REPLACING stack BY new-stack.
+       PROCEDURE DIVISION USING stack new-stack.
+         CALL "empty" USING
+           BY REFERENCE stack
+           BY REFERENCE p
+         END-CALL
+         IF nil
+           CALL "pop" USING
+             BY REFERENCE stack
+             BY REFERENCE node-info
+           END-CALL
+           CALL "push" USING
+             BY REFERENCE new-stack
+             BY REFERENCE node-info
+           END-CALL
+           CALL "reverse-stack" USING
+             BY REFERENCE stack
+             BY REFERENCE new-stack
+           END-CALL
+           CALL "push" USING
+             BY REFERENCE stack
+             BY REFERENCE node-info
+           END-CALL
+         END-IF
+         GOBACK.
+       END PROGRAM reverse-stack.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. traverse-stack.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY p.
+       COPY node-info.
+       COPY stack REPLACING stack BY new-stack.
+       LINKAGE SECTION.
+       COPY stack.
+       PROCEDURE DIVISION USING stack.
+         CALL "copy-stack" USING
+           BY REFERENCE stack
+           BY REFERENCE new-stack
+         END-CALL
+         CALL "empty" USING
+           BY REFERENCE new-stack
+           BY REFERENCE p
+         END-CALL
+         IF nil
+           CALL "head" USING
+             BY CONTENT new-stack
+             BY REFERENCE node-info
+           END-CALL
+           DISPLAY node-info END-DISPLAY
+           CALL "peek" USING
+             BY CONTENT new-stack
+             BY REFERENCE node-info
+           END-CALL
+           DISPLAY node-info END-DISPLAY
+           CALL "pop" USING
+             BY REFERENCE new-stack
+             BY REFERENCE node-info
+           END-CALL
+           DISPLAY node-info END-DISPLAY
+           CALL "traverse-stack" USING
+             BY REFERENCE new-stack
+           END-CALL
+         END-IF
+         GOBACK.
+       END PROGRAM traverse-stack.

Task/Stack/COBOL/stack-6.cob

@@ -0,0 +1,37 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. stack-test.
+       DATA DIVISION.
+       LOCAL-STORAGE SECTION.
+       COPY stack.
+       COPY stack REPLACING stack BY new-stack.
+       PROCEDURE DIVISION.
+         CALL "push" USING
+           BY REFERENCE stack
+           BY CONTENT "daleth"
+         END-CALL
+         CALL "push" USING
+           BY REFERENCE stack
+           BY CONTENT "gimel"
+         END-CALL
+         CALL "push" USING
+           BY REFERENCE stack
+           BY CONTENT "beth"
+         END-CALL
+         CALL "push" USING
+           BY REFERENCE stack
+           BY CONTENT "aleph"
+         END-CALL
+         CALL "traverse-stack" USING
+           BY REFERENCE stack
+         END-CALL
+         CALL "reverse-stack" USING
+           BY REFERENCE stack
+           BY REFERENCE new-stack
+         END-CALL
+         CALL "traverse-stack" USING
+           BY REFERENCE new-stack
+         END-CALL
+         STOP RUN.
+       END PROGRAM stack-test.
+
+       COPY stack-utilities.

Task/Stack/Gleam/stack.gleam

@@ -0,0 +1,38 @@
+import gleam/option.{type Option, None, Some}
+
+/// Stack(a) is just an alias for a List(a)
+pub type Stack(a) =
+  List(a)
+
+/// An empty stack is an empty list.
+pub const empty = []
+
+/// is_empty(s) checks if the stack s is empty.
+pub fn is_empty(stack: Stack(a)) -> Bool {
+  case stack {
+    [] -> True
+    _ -> False
+  }
+}
+
+/// push(s,x) pushes the element x onto the stack s.
+pub fn push(stack: Stack(a), x: a) -> Stack(a) {
+  [x, ..stack]
+}
+
+/// peek(s) returns the TOS.
+pub fn peek(stack: Stack(a)) -> Result(a, Nil) {
+  case stack {
+    [] -> Error(Nil)
+    [h, ..] -> Ok(h)
+  }
+}
+
+/// pop(s) pops an element from the TOS, and returns that
+/// and the modified stack.
+pub fn pop(stack: Stack(a)) -> Result(#(a, Stack(a)), Nil) {
+  case stack {
+    [h, ..tl] -> Ok(#(h, tl))
+    _ -> Error(Nil)
+  }
+}

Task/Stack/Oberon-07/stack-1.oberon

@@ -0,0 +1,43 @@
+MODULE StackOfInteger;
+
+    TYPE   T                = INTEGER;
+           Element          = RECORD value : T; next : POINTER TO Element END;
+           StackRecord      = RECORD top   : POINTER TO Element           END;
+           Stack*           = POINTER TO StackRecord;
+
+    PROCEDURE push*( s : Stack; v : T );
+        VAR   newElement : POINTER TO Element;
+        BEGIN
+           NEW( newElement );
+           newElement.value := v;
+           newElement.next  := s.top;
+           s.top            := newElement
+        END push;
+
+    PROCEDURE peek*( s : Stack ) : T;
+        BEGIN
+        RETURN s.top.value
+        END peek;
+
+    PROCEDURE pop*( s : Stack ) : T;
+        VAR   v : T;
+        BEGIN
+           v     := peek( s );
+           s.top := s.top.next
+        RETURN v
+        END pop;
+
+    PROCEDURE empty*( s : Stack ) : BOOLEAN;
+        BEGIN
+        RETURN s.top = NIL
+        END empty;
+
+    PROCEDURE newStack*() : Stack;
+        VAR s : Stack;
+        BEGIN
+           NEW( s );
+           s.top  := NIL;
+        RETURN s
+        END newStack;
+
+END StackOfInteger.

Task/Stack/Oberon-07/stack-2.oberon

@@ -0,0 +1,26 @@
+MODULE UseStack; (* use the StackOfInteger module *)
+   IMPORT Out, SI := StackOfInteger; (* imports StackOfInteger under the name "SI" *)
+
+   VAR    st     : SI.Stack;
+          v, sum : INTEGER;
+
+BEGIN
+
+   st := SI.newStack();                           (* create a stack *)
+
+   SI.push( st,   1 );                            (* add some items *)
+   SI.push( st,  23 );
+   SI.push( st, 456 );
+
+   WHILE ~ SI.empty( st ) DO    (* unstack, sum and print the items *)
+      v := SI.pop( st );
+      INC( sum, v );
+      Out.Int( v, 0 );
+      IF ~ SI.empty( st ) THEN
+         Out.String( " (" );Out.Int( SI.peek( st ), 0 );Out.String( ")" )
+      END;
+      Out.Ln
+   END;
+   Out.String( "sum: " );Out.Int( sum, 0 );Out.Ln
+
+END UseStack.

Task/Stack/PowerShell/stack-1.ps1

@@ -0,0 +1,3 @@
+$stack = New-Object -TypeName System.Collections.Stack
+# or
+$stack = [System.Collections.Stack] @()

Task/Stack/PowerShell/stack-2.ps1

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

Task/Stack/PowerShell/stack-3.ps1

@@ -0,0 +1 @@
+$stack -join ", "

Task/Stack/PowerShell/stack-4.ps1

@@ -0,0 +1 @@
+$stack.Pop()

Task/Stack/PowerShell/stack-5.ps1

@@ -0,0 +1 @@
+$stack -join ", "

Task/Stack/PowerShell/stack-6.ps1

@@ -0,0 +1 @@
+$stack.Peek()

Task/Stack/PowerShell/stack-7.ps1

@@ -0,0 +1 @@
+$stack

Task/Stack/Rebol/stack-1.rebol

@@ -0,0 +1,6 @@
+stack: copy []
+append stack 1  ;== [1]
+append stack 2  ;== [1 2]
+take/last stack ;== 2
+take/last stack ;== 1
+empty? stack    ;== true

Task/Stack/Rebol/stack-2.rebol

@@ -0,0 +1,34 @@
+Rebol [
+	Title: "Stack"
+	URL: http://rosettacode.org/wiki/Stack
+]
+
+stack: make object! [
+	data: copy []
+
+	push: func [x][append data x]
+	pop: func [/local x][x: last data  remove back tail data  x]
+	empty: does [empty? data]
+
+	peek: does [last data]
+]
+
+; Teeny Tiny Test Suite
+
+assert: func [code][print [either do code ["  ok"]["FAIL"]  mold code]]
+
+print "Simple integers:"
+s: make stack []  s/push 1  s/push 2 ; Initialize.
+
+assert [2 = s/peek]
+assert [2 = s/pop]
+assert [1 = s/pop]
+assert [s/empty]
+
+print [lf "Symbolic data on stack:"]
+v: make stack [data: [this is a test]] ; Initialize on instance.
+
+assert ['test = v/peek]
+assert ['test = v/pop]
+assert ['a = v/pop]
+assert [not v/empty]

Task/Stack/VBScript/stack-1.vbs

@@ -0,0 +1,56 @@
+class stack
+	dim tos
+	dim stack()
+	dim stacksize
+	
+	private sub class_initialize
+		stacksize = 100
+		redim stack( stacksize )
+		tos = 0
+	end sub
+
+	public sub push( x )
+		stack(tos) = x
+		tos = tos + 1
+	end sub
+	
+	public property get stackempty
+		stackempty = ( tos = 0 )
+	end property
+	
+	public property get stackfull
+		stackfull = ( tos > stacksize )
+	end property
+	
+	public property get stackroom
+		stackroom = stacksize - tos
+	end property
+	
+	public function pop()
+		pop = stack( tos - 1 )
+		tos = tos - 1
+	end function
+
+	public sub resizestack( n )
+		redim preserve stack( n )
+		stacksize = n
+		if tos > stacksize then
+			tos = stacksize
+		end if
+	end sub
+end class
+
+dim s
+set s = new stack
+s.resizestack 10
+wscript.echo s.stackempty
+dim i
+for i = 1 to 10
+	s.push rnd
+	wscript.echo s.stackroom
+	if s.stackroom = 0 then exit for
+next
+for i = 1 to 10
+	wscript.echo s.pop
+	if s.stackempty then exit for
+next

Task/Stack/VBScript/stack-2.vbs

@@ -0,0 +1,39 @@
+' Stack Definition - VBScript
+
+Option Explicit
+
+Dim stack, i, x
+Set stack = CreateObject("System.Collections.ArrayList")
+If Not empty_(stack) Then Wscript.Echo stack.Count
+push stack, "Banana"
+push stack, "Apple"
+push stack, "Pear"
+push stack, "Strawberry"
+Wscript.Echo "Count=" & stack.Count 		    ' --> Count=4
+Wscript.Echo pop(stack) & " - Count=" & stack.Count ' --> Strawberry - Count=3
+Wscript.Echo "Tail=" & stack.Item(0) 		    ' --> Tail=Banana
+Wscript.Echo "Head=" & stack.Item(stack.Count-1)    ' --> Head=Pear
+Wscript.Echo stack.IndexOf("Apple", 0)   	    ' --> 1
+For i=1 To stack.Count
+	Wscript.Echo join(stack.ToArray(), ", ")
+	x = pop(stack)
+Next 'i
+
+Sub push(s, what)
+    s.Add what
+End Sub 'push
+
+Function pop(s)
+	Dim what
+    If s.Count > 0 Then
+        what = s(s.Count-1)
+        s.RemoveAt s.Count-1
+    Else
+        what = ""
+    End If
+    pop = what
+End Function 'pop
+
+Function empty_(s)
+    empty_ = s.Count = 0
+End Function 'empty_