TypeScript Stack with Generics

Common errors

• Argument of type 'string | number' is not assignable to parameter of type 'string'. Type 'number' is not assignable to type 'string'.

  cause Attempting to initialize or push a value of a different type than the generic type parameter specified for the stack.
  fix Ensure all values provided to the stack (during instantiation or via `push`) strictly adhere to the generic type parameter. For mixed types, use `Stack<any>` or a union type if appropriate (e.g., `Stack<string | number>`). ```typescript // Wrong: let items: (string | number)[] = ['one', 'two', 3]; let stack = new Stack<string>(...items); // Correct: let items: (string | number)[] = ['one', 'two', 3]; let stack = new Stack<string | number>(...items); ```

Warnings

• gotcha When initializing a Stack with values (e.g., `new Stack<number>(...items)`), the items are pushed from left-to-right into the stack. This means the *first* argument provided will become the *top* of the stack, and the *last* argument will be at the *bottom*. This is inverse to how an array `push` would naturally order elements if interpreted as 'first in, first at bottom'.
  Fix: Be mindful of argument order during instantiation. If you want `a` to be at the bottom and `c` at the top, use `new Stack<string>('a', 'b', 'c');`.
• gotcha The Stack stores references to objects, not copies. Modifying an object retrieved from the stack (e.g., via `top` or `pop()`) will affect the object within the stack if it is later pushed back, or if other references to the same object exist.
  Fix: If deep copies are required to maintain immutability or isolated state, ensure you create copies of objects before pushing them onto the stack or before modifying them after retrieval.
• gotcha Using `new Stack()` without specifying a generic type parameter `<T>` will result in a stack of type `Stack<any>`. This will bypass TypeScript's type-checking and defeat the purpose of using a generic data structure.
  Fix: Always explicitly define the generic type, e.g., `new Stack<MyType>()` or `new Stack<string>()`, to ensure type safety.

Install

• npm install stack-typescript npm
• yarn add stack-typescript yarn
• pnpm add stack-typescript pnpm

Imports

• Stack
  wrong:

  import Stack from 'stack-typescript';

  correct:

  import { Stack } from 'stack-typescript';

  Stack is a named export, not a default export.
• Stack

  const { Stack } = require('stack-typescript');

  For CommonJS environments, destructure the named export directly.
• Stack<T>
  wrong:

  let myStack = new Stack();

  correct:

  let myStack = new Stack<string>();

  Always specify the generic type parameter `<T>` when initializing a new Stack to leverage TypeScript's full type-checking capabilities. Omitting it will default to `any`.

Quickstart

Demonstrates creating, initializing, pushing, peeking, popping, and iterating a Stack with both primitive and custom types.

import { Stack } from 'stack-typescript';

// Create an empty stack of numbers
let numberStack = new Stack<number>();
numberStack.push(10);
numberStack.push(20);
numberStack.push(30);

console.log(`Number Stack Size: ${numberStack.size}`); // Expected: 3
console.log(`Top of Number Stack: ${numberStack.top}`); // Expected: 30

// Initialize a stack with values and custom types
class Foo {
  constructor(public val: number) {}
  get bar(): number { return this.val; }
}

let foo1 = new Foo(100);
let foo2 = new Foo(200);
let fooStack = new Stack<Foo>(foo1, foo2, new Foo(300));

console.log(`Foo Stack Size: ${fooStack.size}`); // Expected: 3
console.log(`Top of Foo Stack: ${fooStack.top?.bar}`); // Expected: 100

let poppedFoo = fooStack.pop();
console.log(`Popped Foo: ${poppedFoo?.bar}`); // Expected: 100
console.log(`Foo Stack Size after pop: ${fooStack.size}`); // Expected: 2

// Iterate over the stack
console.log('Iterating over Foo Stack:');
for (let item of fooStack) {
  console.log(item.bar);
}
// Expected: 200, 300