Rename push/pop to give/get, since it's not stack-ordered

5 files changed, 42 insertions, 42 deletions

diff --git a/builtins/channel.c b/builtins/channel.c
index d64f22c9..f47a0b11 100644
--- a/builtins/channel.c
+++ b/builtins/channel.c
@@ -30,7 +30,7 @@ public channel_t *Channel$new(Int_t max_size)
     return channel;
 }
 
-public void Channel$push(channel_t *channel, const void *item, int64_t padded_item_size)
+public void Channel$give(channel_t *channel, const void *item, int64_t padded_item_size)
 {
     (void)pthread_mutex_lock(&channel->mutex);
     while (channel->items.length >= channel->max_size)
@@ -40,24 +40,24 @@ public void Channel$push(channel_t *channel, const void *item, int64_t padded_it
     (void)pthread_cond_signal(&channel->cond);
 }
 
-public void Channel$push_all(channel_t *channel, array_t to_push, int64_t padded_item_size)
+public void Channel$give_all(channel_t *channel, array_t to_give, int64_t padded_item_size)
 {
-    if (to_push.length == 0) return;
+    if (to_give.length == 0) return;
     (void)pthread_mutex_lock(&channel->mutex);
-    if (channel->items.length + to_push.length >= channel->max_size) {
-        for (int64_t i = 0; i < to_push.length; i++) {
+    if (channel->items.length + to_give.length >= channel->max_size) {
+        for (int64_t i = 0; i < to_give.length; i++) {
             while (channel->items.length >= channel->max_size)
                 pthread_cond_wait(&channel->cond, &channel->mutex);
-            Array$insert(&channel->items, to_push.data + i*to_push.stride, I(0), padded_item_size);
+            Array$insert(&channel->items, to_give.data + i*to_give.stride, I(0), padded_item_size);
         }
     } else {
-        Array$insert_all(&channel->items, to_push, I(0), padded_item_size);
+        Array$insert_all(&channel->items, to_give, I(0), padded_item_size);
     }
     (void)pthread_mutex_unlock(&channel->mutex);
     (void)pthread_cond_signal(&channel->cond);
 }
 
-public void Channel$pop(channel_t *channel, void *out, int64_t item_size, int64_t padded_item_size)
+public void Channel$get(channel_t *channel, void *out, int64_t item_size, int64_t padded_item_size)
 {
     (void)pthread_mutex_lock(&channel->mutex);
     while (channel->items.length == 0)
diff --git a/builtins/channel.h b/builtins/channel.h
index c5a612ce..3b2d2c16 100644
--- a/builtins/channel.h
+++ b/builtins/channel.h
@@ -10,11 +10,11 @@
 #include "util.h"
 
 channel_t *Channel$new(Int_t max_size);
-void Channel$push(channel_t *channel, const void *item, int64_t padded_item_size);
-#define Channel$push_value(channel, item, padded_item_size) ({ __typeof(item) _item = item; Channel$push(channel, &_item, padded_item_size); })
-void Channel$push_all(channel_t *channel, array_t to_push, int64_t padded_item_size);
-void Channel$pop(channel_t *channel, void *out, int64_t item_size, int64_t padded_item_size);
-#define Channel$pop_value(channel, t, padded_item_size) ({ t _val; Channel$pop(channel, &_val, sizeof(t), padded_item_size); _val; })
+void Channel$give(channel_t *channel, const void *item, int64_t padded_item_size);
+#define Channel$give_value(channel, item, padded_item_size) ({ __typeof(item) _item = item; Channel$give(channel, &_item, padded_item_size); })
+void Channel$give_all(channel_t *channel, array_t to_give, int64_t padded_item_size);
+void Channel$get(channel_t *channel, void *out, int64_t item_size, int64_t padded_item_size);
+#define Channel$get_value(channel, t, padded_item_size) ({ t _val; Channel$get(channel, &_val, sizeof(t), padded_item_size); _val; })
 void Channel$clear(channel_t *channel);
 array_t Channel$view(channel_t *channel);
 uint32_t Channel$hash(const channel_t **channel, const TypeInfo *type);
diff --git a/compile.c b/compile.c
index 748f5541..08b56938 100644
--- a/compile.c
+++ b/compile.c
@@ -2363,20 +2363,20 @@ CORD compile(env_t *env, ast_t *ast)
         case ChannelType: {
             type_t *item_t = Match(self_value_t, ChannelType)->item_type;
             CORD padded_item_size = CORD_asprintf("%ld", padded_type_size(item_t));
-            if (streq(call->name, "push")) {
+            if (streq(call->name, "give")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
                 arg_t *arg_spec = new(arg_t, .name="item", .type=item_t);
-                return CORD_all("Channel$push_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Channel$give_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 padded_item_size, ")");
-            } else if (streq(call->name, "push_all")) {
+            } else if (streq(call->name, "give_all")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
-                arg_t *arg_spec = new(arg_t, .name="to_push", .type=Type(ArrayType, .item_type=item_t));
-                return CORD_all("Channel$push_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                arg_t *arg_spec = new(arg_t, .name="to_give", .type=Type(ArrayType, .item_type=item_t));
+                return CORD_all("Channel$give_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 padded_item_size, ")");
-            } else if (streq(call->name, "pop")) {
+            } else if (streq(call->name, "get")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
                 (void)compile_arguments(env, ast, NULL, call->args);
-                return CORD_all("Channel$pop_value(", self, ", ", compile_type(item_t), ", ", padded_item_size, ")");
+                return CORD_all("Channel$get_value(", self, ", ", compile_type(item_t), ", ", padded_item_size, ")");
             } else if (streq(call->name, "clear")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
                 (void)compile_arguments(env, ast, NULL, call->args);
diff --git a/test/threads.tm b/test/threads.tm
index 95cfbb5b..e8d83f4a 100644
--- a/test/threads.tm
+++ b/test/threads.tm
@@ -6,40 +6,40 @@ func main():
     >> thread := Thread.new(func():
         //! In another thread!
         while yes:
-            >> got := jobs:pop()
+            >> got := jobs:get()
             when got is Increment(x):
-                >> results:push(x+1)
+                >> results:give(x+1)
             is Decrement(x):
-                >> results:push(x-1)
+                >> results:give(x-1)
     )
 
-    >> jobs:push(Increment(5))
-    >> jobs:push(Decrement(100))
-    >> jobs:push(Decrement(100))
-    >> jobs:push(Decrement(100))
-    >> jobs:push(Decrement(100))
-    >> jobs:push(Decrement(100))
-    >> jobs:push(Decrement(100))
+    >> jobs:give(Increment(5))
+    >> jobs:give(Decrement(100))
+    >> jobs:give(Decrement(100))
+    >> jobs:give(Decrement(100))
+    >> jobs:give(Decrement(100))
+    >> jobs:give(Decrement(100))
+    >> jobs:give(Decrement(100))
 
-    >> results:pop()
+    >> results:get()
     = 6
 
-    >> jobs:push(Increment(1000))
-    >> results:pop()
+    >> jobs:give(Increment(1000))
+    >> results:get()
     = 99
 
-    >> results:pop()
+    >> results:get()
     = 99
-    >> results:pop()
+    >> results:get()
     = 99
-    >> results:pop()
+    >> results:get()
     = 99
-    >> results:pop()
+    >> results:get()
     = 99
-    >> results:pop()
+    >> results:get()
     = 99
 
-    >> results:pop()
+    >> results:get()
     = 1001
 
     //! Canceling...
diff --git a/typecheck.c b/typecheck.c
index 1018f33e..805f83e0 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -771,9 +771,9 @@ type_t *get_type(env_t *env, ast_t *ast)
         }
         case ChannelType: {
             if (streq(call->name, "clear")) return Type(VoidType);
-            else if (streq(call->name, "pop")) return Match(self_value_t, ChannelType)->item_type;
-            else if (streq(call->name, "push")) return Type(VoidType);
-            else if (streq(call->name, "push_all")) return Type(VoidType);
+            else if (streq(call->name, "get")) return Match(self_value_t, ChannelType)->item_type;
+            else if (streq(call->name, "give")) return Type(VoidType);
+            else if (streq(call->name, "give_all")) return Type(VoidType);
             else if (streq(call->name, "view")) return Type(ArrayType, .item_type=Match(self_value_t, ChannelType)->item_type);
             else code_err(ast, "There is no '%s' method for arrays", call->name);
         }