Prepare for transfer to Raku Community Modules

Author: lizmat

.github/workflows/test.yml

@@ -0,0 +1,28 @@
+name: test
+
+on:
+  push:
+    branches:
+      - '*'
+    tags-ignore:
+      - '*'
+  pull_request:
+
+jobs:
+  raku:
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macOS-latest
+          - windows-latest
+        raku-version:
+          - 'latest'
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: Raku/setup-raku@v1
+        with:
+          raku-version: ${{ matrix.raku-version }}
+      - name: Run Tests
+        run: raku run-tests

.gitignore

@@ -1 +1,2 @@
 .precomp/
+/Concurrent-Stack-*

.travis.yml

@@ -0,0 +1,4 @@
+Revision history for Concurrent-Stack
+
+{{$NEXT}}
+    - Initial version in zef ecosystem

Changes

@@ -1,16 +1,25 @@
 {
-  "name": "Concurrent::Stack",
-  "description": "A lock-free concurrent stack data structure.",
-  "version": "1.2",
-  "perl": "6.*",
+  "auth": "zef:raku-community-modules",
   "authors": [
     "Jonathan Worthington <jnthn@jnthn.net>"
   ],
-  "depends": [],
+  "build-depends": [
+  ],
+  "depends": [
+  ],
+  "description": "A lock-free concurrent stack data structure",
+  "license": "Artistic-2.0",
+  "name": "Concurrent::Stack",
+  "perl": "6.c",
   "provides": {
-    "Concurrent::Stack": "lib/Concurrent/Stack.pm6"
+    "Concurrent::Stack": "lib/Concurrent/Stack.rakumod"
   },
-  "resources": [],
-  "license": "Artistic-2.0",
-  "source-url": "https://github.com/jnthn/p6-concurrent-stack.git"
+  "resources": [
+  ],
+  "source-url": "https://github.com/raku-community-modules/Concurrent-Stack.git",
+  "tags": [
+  ],
+  "test-depends": [
+  ],
+  "version": "1.2"
 }

META6.json

@@ -1,94 +1,94 @@
-# Concurrent::Stack
+[![Actions Status](https://github.com/lizmat/Concurrent-Stack/actions/workflows/test.yml/badge.svg)](https://github.com/lizmat/Concurrent-Stack/actions)
 
-A lock-free stack data structure, safe for concurrent use.
+NAME
+====
 
-## Synopsis
+Concurrent::Stack - A lock-free concurrent stack data structure
 
-    use Concurrent::Stack;
+SYNOPSIS
+========
 
-    my $stack = Concurrent::Stack.new;
+```raku
+use Concurrent::Stack;
 
-    for 'a'..'z' {
-        $stack.push($_);
-    }
+my $stack = Concurrent::Stack.new;
 
-    say $stack.elems;       # 26
-    say $stack.peek;        # z
-    say $stack.pop;         # z
-    say $stack.pop;         # y
-    say $stack.peek;        # x
-    $stack.push('k');
-    say $stack.peek;        # k
-    say $stack.elems;       # 25
-    say $stack.Seq;         # A Seq iterating a snapshot of the stack
-    say $stack.list;        # A lazy List with a snapshot of the stack
+for 'a'..'z' {
+    $stack.push($_);
+}
 
-    $stack.pop for ^25;
-    say $stack.elems;       # 0
-    my $x = $stack.peek;    # Failure with X::Concurrent::Stack::Empty 
-    my $y = $stack.pop;     # Failure with X::Concurrent::Stack::Empty
+say $stack.elems;     # 26
+say $stack.peek;      # z
+say $stack.pop;       # z
+say $stack.pop;       # y
+say $stack.peek;      # x
+$stack.push('k');
+say $stack.peek;      # k
+say $stack.elems;     # 25
+say $stack.Seq;       # A Seq iterating a snapshot of the stack
+say $stack.list;      # A lazy List with a snapshot of the stack
 
-## Overview
+$stack.pop for ^25;
+say $stack.elems;     # 0
+my $x = $stack.peek;  # Failure with X::Concurrent::Stack::Empty 
+my $y = $stack.pop;   # Failure with X::Concurrent::Stack::Empty
+```
 
-Lock-free data structures may be safely used from multiple threads, yet do not
-use locks in their implementation. They achieve this through the use of atomic
-operations provided by the hardware. Nothing can make contention between
-threads cheap - synchronization at the CPU level is still synchronization -
-but lock free data structures tend to scale better.
+DESCRIPTION
+===========
 
-This lock-free stack data structure uses a linked list of immutable nodes, the
-only mutable state being a head pointer to the node representing the stack top
-and an element counter mintained through atomic increment/decrement operations.
-The element count updates are not performed as part of the stack update, and so
-may lag the actual state of the stack. However, since checking the number of
-elements to decide whether to `peek` or `pop` is doomed in a concurrent setting
-anyway (since another thread may `pop` the last value in the meantime), this is
-not problematic. The `elems` method primarily exists so that the number of
-elements can be queried once the stack reaches some known stable point (for
-example, when a bunch of working threads that `push` to it are all known to
-have completed their work).
+Lock-free data structures may be safely used from multiple threads, yet do not use locks in their implementation. They achieve this through the use of atomic operations provided by the hardware. Nothing can make contention between threads cheap - synchronization at the CPU level is still synchronization - but lock free data structures tend to scale better.
 
-### Methods
+This lock-free stack data structure uses a linked list of immutable nodes, the only mutable state being a head pointer to the node representing the stack top and an element counter mintained through atomic increment/decrement operations. The element count updates are not performed as part of the stack update, and so may lag the actual state of the stack. However, since checking the number of elements to decide whether to `peek` or `pop` is doomed in a concurrent setting anyway (since another thread may `pop` the last value in the meantime), this is not problematic. The `elems` method primarily exists so that the number of elements can be queried once the stack reaches some known stable point (for example, when a bunch of working threads that `push` to it are all known to have completed their work).
 
-#### push(Any $value)
+METHODS
+=======
+
+push(Any $value)
+----------------
 
 Pushes a value onto the stack. Returns the value that was pushed.
 
-#### pop()
+pop()
+-----
+
+If the stack is not empty, removes the top value and returns it. Otherwise, returns a `Failure` containing an exception of typei `X::Concurrent::Stack::Empty`.
+
+peek()
+------
+
+If the stack is not empty, returns the top value. Otherwise, returns a `Failure` containing an exception of type `X::Concurrent::Stack::Empty`.
+
+elems()
+-------
+
+Returns the number of elements on the stack. This value can only be relied upon when it is known that no threads are pushing/popping from the stack at the point this method is called. **Never** use the result of `elems` to decide whether to `peek` or `pop`, since another thread may `pop` in the meantime. Instead, check if `peek` or `pop` return a `Failure`.
+
+head2 Bool()
+
+Returns `False` if the stack is empty and `True` if the stack is non-empty. The result can only be relied upon when it is known that no threads are pushing/popping from the stack at the point this method is called. **Never** use the result of `Bool` to decide whether to `peek` or `pop`, since another thread may `pop` in the meantime. Instead, check if `peek` or `pop` return a `Failure`.
 
-If the stack is not empty, removes the top value and returns it. Otherwise,
-returns a `Failure` containing an exception of type `X::Concurrent::Stack::Empty`.
+Seq()
+-----
 
-#### peek()
+Returns a `Seq` that will iterate to a snapshot of the stack content, starting from the stack top. The snapshot is made at the time this method is called.
 
-If the stack is not empty, returns the top value. Otherwise, returns a `Failure`
-containing an exception of type `X::Concurrent::Stack::Empty`.
+list()
+------
 
-#### elems()
+Returns a `List` that will lazily evaluate to a snapshot of the stack content, starting from the stack top. The snapshot is made at the time this method is called.
 
-Returns the number of elements on the stack. This value can only be relied upon
-when it is known that no threads are pushing/popping from the stack at the
-point this method is called. Never use the result of `elems` to decide whether
-to `peek` or `pop`, since another thread may `pop` in the meantime. Instead,
-check if `peek` or `pop` return a `Failure`.
+AUTHOR
+======
 
-#### Bool()
+Jonathan Worthington
 
-Returns `False` if the stack is empty and `True` if the stack is non-empty.
-The result can only be relied upon when it is known that no threads are
-pushing/popping from the stack at the point this method is called. Never use
-the result of `Bool` to decide whether to `peek` or `pop`, since another
-thread may `pop` in the meantime. Instead, check if `peek` or `pop` return a
-`Failure`.
+COPYRIGHT AND LICENSE
+=====================
 
-#### Seq()
+Copyright 2018 - 2024 Raku Community
 
-Returns a `Seq` that will iterate to a snapshot of the stack content,
-starting from the stack top. The snapshot is made at the time this
-method is called.
+Copyright 2024 Raku Community
 
-#### list()
+This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
 
-Returns a `List` that will lazily evaluate to a snapshot of the stack
-content, starting from the stack top. The snapshot is made at the time
-this method is called.

README.md

@@ -0,0 +1,9 @@
+name = Concurrent-Stack
+
+[ReadmeFromPod]
+filename = lib/Concurrent/Stack.rakumod
+
+[UploadToZef]
+
+[Badges]
+provider = github-actions/test.yml