add ci

Author: hellerve

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Carp
+        uses: carpentry-org/setup-carp@v1
+
+      - name: Run tests
+        run: |
+          set -euo pipefail
+          carp -x tests/int16.carp
+          carp -x tests/int32.carp
+          carp -x tests/int64.carp
+          carp -x tests/int8.carp
+          carp -x tests/uint16.carp
+          carp -x tests/uint32.carp
+          carp -x tests/uint64.carp
+          carp -x tests/uint8.carp

stdint.carp

@@ -28,15 +28,30 @@
   (register str (λ [Int8] String))
   (register copy (Fn [&Int8] Int8))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Int8.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Int8)))
+  (implements + Int8.+)
+  (implements - Int8.-)
+  (implements * Int8.*)
+  (implements / Int8./)
+  (implements < Int8.<)
+  (implements > Int8.>)
+  (implements = Int8.=)
+  (implements copy Int8.copy)
+  (implements zero Int8.zero)
+  (implements bit-shift-left Int8.bit-shift-left)
+  (implements bit-shift-right Int8.bit-shift-right)
+  (implements bit-and Int8.bit-and)
+  (implements bit-or Int8.bit-or)
+  (implements bit-xor Int8.bit-xor)
+  (implements bit-not Int8.bit-not)
 )
 
 (defmodule Int8Extra
-  (defn prn [a] (Int8.prn @a))
-  (defn str [a] (Int8.str @a))
   (defn = [a b] (Int8.= @a @b))
+  (implements = Int8Extra.=)
 )
 
 (defmodule Int16
@@ -58,15 +73,30 @@
   (register str (λ [Int16] String))
   (register copy (Fn [&Int16] Int16))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Int16.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Int16)))
+  (implements + Int16.+)
+  (implements - Int16.-)
+  (implements * Int16.*)
+  (implements / Int16./)
+  (implements < Int16.<)
+  (implements > Int16.>)
+  (implements = Int16.=)
+  (implements copy Int16.copy)
+  (implements zero Int16.zero)
+  (implements bit-shift-left Int16.bit-shift-left)
+  (implements bit-shift-right Int16.bit-shift-right)
+  (implements bit-and Int16.bit-and)
+  (implements bit-or Int16.bit-or)
+  (implements bit-xor Int16.bit-xor)
+  (implements bit-not Int16.bit-not)
 )
 
 (defmodule Int16Extra
-  (defn prn [a] (Int16.prn @a))
-  (defn str [a] (Int16.str @a))
   (defn = [a b] (Int16.= @a @b))
+  (implements = Int16Extra.=)
 )
 
 (defmodule Int32
@@ -88,15 +118,30 @@
   (register str (λ [Int32] String))
   (register copy (Fn [&Int32] Int32))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Int32.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Int32)))
+  (implements + Int32.+)
+  (implements - Int32.-)
+  (implements * Int32.*)
+  (implements / Int32./)
+  (implements < Int32.<)
+  (implements > Int32.>)
+  (implements = Int32.=)
+  (implements copy Int32.copy)
+  (implements zero Int32.zero)
+  (implements bit-shift-left Int32.bit-shift-left)
+  (implements bit-shift-right Int32.bit-shift-right)
+  (implements bit-and Int32.bit-and)
+  (implements bit-or Int32.bit-or)
+  (implements bit-xor Int32.bit-xor)
+  (implements bit-not Int32.bit-not)
 )
 
 (defmodule Int32Extra
-  (defn prn [a] (Int32.prn @a))
-  (defn str [a] (Int32.str @a))
   (defn = [a b] (Int32.= @a @b))
+  (implements = Int32Extra.=)
 )
 
 (defmodule Int64
@@ -118,15 +163,30 @@
   (register str (λ [Int64] String))
   (register copy (Fn [&Int64] Int64))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Int64.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Int64)))
+  (implements + Int64.+)
+  (implements - Int64.-)
+  (implements * Int64.*)
+  (implements / Int64./)
+  (implements < Int64.<)
+  (implements > Int64.>)
+  (implements = Int64.=)
+  (implements copy Int64.copy)
+  (implements zero Int64.zero)
+  (implements bit-shift-left Int64.bit-shift-left)
+  (implements bit-shift-right Int64.bit-shift-right)
+  (implements bit-and Int64.bit-and)
+  (implements bit-or Int64.bit-or)
+  (implements bit-xor Int64.bit-xor)
+  (implements bit-not Int64.bit-not)
 )
 
 (defmodule Int64Extra
-  (defn prn [a] (Int64.prn @a))
-  (defn str [a] (Int64.str @a))
   (defn = [a b] (Int64.= @a @b))
+  (implements = Int64Extra.=)
 )
 
 (defmodule Uint8
@@ -148,15 +208,30 @@
   (register str (λ [Uint8] String))
   (register copy (Fn [&Uint8] Uint8))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Uint8.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Uint8)))
+  (implements + Uint8.+)
+  (implements - Uint8.-)
+  (implements * Uint8.*)
+  (implements / Uint8./)
+  (implements < Uint8.<)
+  (implements > Uint8.>)
+  (implements = Uint8.=)
+  (implements copy Uint8.copy)
+  (implements zero Uint8.zero)
+  (implements bit-shift-left Uint8.bit-shift-left)
+  (implements bit-shift-right Uint8.bit-shift-right)
+  (implements bit-and Uint8.bit-and)
+  (implements bit-or Uint8.bit-or)
+  (implements bit-xor Uint8.bit-xor)
+  (implements bit-not Uint8.bit-not)
 )
 
 (defmodule Uint8Extra
-  (defn prn [a] (Uint8.prn @a))
-  (defn str [a] (Uint8.str @a))
   (defn = [a b] (Uint8.= @a @b))
+  (implements = Uint8Extra.=)
 )
 
 (defmodule Uint16
@@ -178,15 +253,30 @@
   (register str (λ [Uint16] String))
   (register copy (Fn [&Uint16] Uint16))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Uint16.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Uint16)))
+  (implements + Uint16.+)
+  (implements - Uint16.-)
+  (implements * Uint16.*)
+  (implements / Uint16./)
+  (implements < Uint16.<)
+  (implements > Uint16.>)
+  (implements = Uint16.=)
+  (implements copy Uint16.copy)
+  (implements zero Uint16.zero)
+  (implements bit-shift-left Uint16.bit-shift-left)
+  (implements bit-shift-right Uint16.bit-shift-right)
+  (implements bit-and Uint16.bit-and)
+  (implements bit-or Uint16.bit-or)
+  (implements bit-xor Uint16.bit-xor)
+  (implements bit-not Uint16.bit-not)
 )
 
 (defmodule Uint16Extra
-  (defn prn [a] (Uint16.prn @a))
-  (defn str [a] (Uint16.str @a))
   (defn = [a b] (Uint16.= @a @b))
+  (implements = Uint16Extra.=)
 )
 
 (defmodule Uint32
@@ -208,15 +298,30 @@
   (register str (λ [Uint32] String))
   (register copy (Fn [&Uint32] Uint32))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Uint32.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Uint32)))
+  (implements + Uint32.+)
+  (implements - Uint32.-)
+  (implements * Uint32.*)
+  (implements / Uint32./)
+  (implements < Uint32.<)
+  (implements > Uint32.>)
+  (implements = Uint32.=)
+  (implements copy Uint32.copy)
+  (implements zero Uint32.zero)
+  (implements bit-shift-left Uint32.bit-shift-left)
+  (implements bit-shift-right Uint32.bit-shift-right)
+  (implements bit-and Uint32.bit-and)
+  (implements bit-or Uint32.bit-or)
+  (implements bit-xor Uint32.bit-xor)
+  (implements bit-not Uint32.bit-not)
 )
 
 (defmodule Uint32Extra
-  (defn prn [a] (Uint32.prn @a))
-  (defn str [a] (Uint32.str @a))
   (defn = [a b] (Uint32.= @a @b))
+  (implements = Uint32Extra.=)
 )
 
 (defmodule Uint64
@@ -238,13 +343,28 @@
   (register str (λ [Uint64] String))
   (register copy (Fn [&Uint64] Uint64))
 
+  (defn zero [] (from-long 0l))
   (defn prn [a] (Uint64.str a))
 
   (register from-bytes (Fn [&(Array Byte)] (Array Uint64)))
+  (implements + Uint64.+)
+  (implements - Uint64.-)
+  (implements * Uint64.*)
+  (implements / Uint64./)
+  (implements < Uint64.<)
+  (implements > Uint64.>)
+  (implements = Uint64.=)
+  (implements copy Uint64.copy)
+  (implements zero Uint64.zero)
+  (implements bit-shift-left Uint64.bit-shift-left)
+  (implements bit-shift-right Uint64.bit-shift-right)
+  (implements bit-and Uint64.bit-and)
+  (implements bit-or Uint64.bit-or)
+  (implements bit-xor Uint64.bit-xor)
+  (implements bit-not Uint64.bit-not)
 )
 
 (defmodule Uint64Extra
-  (defn prn [a] (Uint64.prn @a))
-  (defn str [a] (Uint64.str @a))
   (defn = [a b] (Uint64.= @a @b))
+  (implements = Uint64Extra.=)
 )