Switch from using dollar signs as namespace delimiters to using 々, ヽ, andunicode-identifiers

〇.

1 files changed, 54 insertions, 54 deletions

diff --git a/src/stdlib/nums.c b/src/stdlib/nums.c
index 3775c8f4..7627c887 100644
--- a/src/stdlib/nums.c
+++ b/src/stdlib/nums.c
@@ -14,17 +14,17 @@
 #include "text.h"
 #include "types.h"
 
-public PUREFUNC Text_t Num$as_text(const void *f, bool colorize, const TypeInfo_t *info) { 
+public PUREFUNC Text_t Numヽas_text(const void *f, bool colorize, const TypeInfo_t *info) { 
     (void)info;
     if (!f) return Text("Num");
     char *str = GC_MALLOC_ATOMIC(24);
     int len = fpconv_dtoa(*(double*)f, str);
     static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m");
-    Text_t text = Text$from_strn(str, (size_t)len);
+    Text_t text = Textヽfrom_strn(str, (size_t)len);
     return colorize ? Texts(color_prefix, text, color_suffix) : text;
 } 
 
-public PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *info) { 
+public PUREFUNC int32_t Numヽcompare(const void *x, const void *y, const TypeInfo_t *info) { 
     (void)info;
     int64_t rx = *(int64_t*)x,
             ry = *(int64_t*)y;
@@ -37,12 +37,12 @@ public PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo
     return (rx > ry) - (rx < ry);
 } 
 
-public PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *info) { 
+public PUREFUNC bool Numヽequal(const void *x, const void *y, const TypeInfo_t *info) { 
     (void)info;
     return *(double*)x == *(double*)y;
 } 
 
-public CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute) {
+public CONSTFUNC bool Numヽnear(double a, double b, double ratio, double absolute) {
     if (ratio < 0) ratio = 0;
     else if (ratio > 1) ratio = 1;
 
@@ -57,13 +57,13 @@ public CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute
     return (diff < epsilon);
 }
 
-public Text_t Num$percent(double f, double precision) { 
+public Text_t Numヽpercent(double f, double precision) { 
     double d = 100. * f;
-    d = Num$with_precision(d, precision);
-    return Texts(Num$as_text(&d, false, &Num$info), Text("%"));
+    d = Numヽwith_precision(d, precision);
+    return Texts(Numヽas_text(&d, false, &Numヽinfo), Text("%"));
 }
 
-public CONSTFUNC double Num$with_precision(double num, double precision) {
+public CONSTFUNC double Numヽwith_precision(double num, double precision) {
     if (precision == 0.0) return num;
     // Precision will be, e.g. 0.01 or 100.
     if (precision < 1.) {
@@ -76,35 +76,35 @@ public CONSTFUNC double Num$with_precision(double num, double precision) {
     }
 }
 
-public CONSTFUNC double Num$mod(double num, double modulus) { 
+public CONSTFUNC double Numヽmod(double num, double modulus) { 
     // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
     double r = remainder(num, modulus);
     r -= (r < 0) * (2*(modulus < 0) - 1) * modulus;
     return r;
 }
 
-public CONSTFUNC double Num$mod1(double num, double modulus) { 
-    return 1.0 + Num$mod(num-1, modulus);
+public CONSTFUNC double Numヽmod1(double num, double modulus) { 
+    return 1.0 + Numヽmod(num-1, modulus);
 }
 
-public CONSTFUNC double Num$mix(double amount, double x, double y) { 
+public CONSTFUNC double Numヽmix(double amount, double x, double y) { 
     return (1.0-amount)*x + amount*y;
 }
 
-public CONSTFUNC bool Num$is_between(const double x, const double low, const double high) {
+public CONSTFUNC bool Numヽis_between(const double x, const double low, const double high) {
     return low <= x && x <= high;
 }
-public CONSTFUNC double Num$clamped(double x, double low, double high) {
+public CONSTFUNC double Numヽclamped(double x, double low, double high) {
     return (x <= low) ? low : (x >= high ? high : x);
 }
 
-public OptionalNum_t Num$parse(Text_t text, Text_t *remainder) {
-    const char *str = Text$as_c_string(text);
+public OptionalNum_t Numヽparse(Text_t text, Text_t *remainder) {
+    const char *str = Textヽas_c_string(text);
     char *end = NULL;
     double d = strtod(str, &end);
     if (end > str) {
         if (remainder)
-            *remainder = Text$from_str(end);
+            *remainder = Textヽfrom_str(end);
         else if (*end != '\0')
             return nan("none");
         return d;
@@ -114,45 +114,45 @@ public OptionalNum_t Num$parse(Text_t text, Text_t *remainder) {
     }
 }
 
-static bool Num$is_none(const void *n, const TypeInfo_t *info)
+static bool Numヽis_none(const void *n, const TypeInfo_t *info)
 {
     (void)info;
     return isnan(*(Num_t*)n);
 }
 
-public CONSTFUNC bool Num$isinf(double n) { return (fpclassify(n) == FP_INFINITE); }
-public CONSTFUNC bool Num$finite(double n) { return (fpclassify(n) != FP_INFINITE); }
-public CONSTFUNC bool Num$isnan(double n) { return (fpclassify(n) == FP_NAN); }
+public CONSTFUNC bool Numヽisinf(double n) { return (fpclassify(n) == FP_INFINITE); }
+public CONSTFUNC bool Numヽfinite(double n) { return (fpclassify(n) != FP_INFINITE); }
+public CONSTFUNC bool Numヽisnan(double n) { return (fpclassify(n) == FP_NAN); }
 
-public const TypeInfo_t Num$info = {
+public const TypeInfo_t Numヽinfo = {
     .size=sizeof(double),
     .align=__alignof__(double),
     .metamethods={
-        .compare=Num$compare,
-        .equal=Num$equal,
-        .as_text=Num$as_text,
-        .is_none=Num$is_none,
+        .compare=Numヽcompare,
+        .equal=Numヽequal,
+        .as_text=Numヽas_text,
+        .is_none=Numヽis_none,
     },
 };
 
-public PUREFUNC Text_t Num32$as_text(const void *f, bool colorize, const TypeInfo_t *info) { 
+public PUREFUNC Text_t Num32ヽas_text(const void *f, bool colorize, const TypeInfo_t *info) { 
     (void)info;
     if (!f) return Text("Num32");
     double d = (double)(*(float*)f);
-    return Num$as_text(&d, colorize, &Num$info);
+    return Numヽas_text(&d, colorize, &Numヽinfo);
 }
 
-public PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *info) { 
+public PUREFUNC int32_t Num32ヽcompare(const void *x, const void *y, const TypeInfo_t *info) { 
     (void)info;
     return (*(float*)x > *(float*)y) - (*(float*)x < *(float*)y);
 } 
 
-public PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *info) { 
+public PUREFUNC bool Num32ヽequal(const void *x, const void *y, const TypeInfo_t *info) { 
     (void)info;
     return *(float*)x == *(float*)y;
 }
 
-public CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute) {
+public CONSTFUNC bool Num32ヽnear(float a, float b, float ratio, float absolute) {
     if (ratio < 0) ratio = 0;
     else if (ratio > 1) ratio = 1;
 
@@ -167,13 +167,13 @@ public CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute)
     return (diff < epsilon);
 }
 
-public Text_t Num32$percent(float f, float precision) { 
+public Text_t Num32ヽpercent(float f, float precision) { 
     double d = 100. * (double)f;
-    d = Num$with_precision(d, (double)precision);
-    return Texts(Num$as_text(&d, false, &Num$info), Text("%"));
+    d = Numヽwith_precision(d, (double)precision);
+    return Texts(Numヽas_text(&d, false, &Numヽinfo), Text("%"));
 }
 
-public CONSTFUNC float Num32$with_precision(float num, float precision) {
+public CONSTFUNC float Num32ヽwith_precision(float num, float precision) {
     if (precision == 0.0f) return num;
     // Precision will be, e.g. 0.01 or 100.
     if (precision < 1.f) {
@@ -186,35 +186,35 @@ public CONSTFUNC float Num32$with_precision(float num, float precision) {
     }
 }
 
-public CONSTFUNC float Num32$mod(float num, float modulus) { 
+public CONSTFUNC float Num32ヽmod(float num, float modulus) { 
     // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
     float r = remainderf(num, modulus);
     r -= (r < 0) * (2*(modulus < 0) - 1) * modulus;
     return r;
 }
 
-public CONSTFUNC float Num32$mod1(float num, float modulus) { 
-    return 1.0f + Num32$mod(num-1, modulus);
+public CONSTFUNC float Num32ヽmod1(float num, float modulus) { 
+    return 1.0f + Num32ヽmod(num-1, modulus);
 }
 
-public CONSTFUNC float Num32$mix(float amount, float x, float y) { 
+public CONSTFUNC float Num32ヽmix(float amount, float x, float y) { 
     return (1.0f-amount)*x + amount*y;
 }
 
-public CONSTFUNC bool Num32$is_between(const float x, const float low, const float high) {
+public CONSTFUNC bool Num32ヽis_between(const float x, const float low, const float high) {
     return low <= x && x <= high;
 }
 
-public CONSTFUNC float Num32$clamped(float x, float low, float high) {
+public CONSTFUNC float Num32ヽclamped(float x, float low, float high) {
     return (x <= low) ? low : (x >= high ? high : x);
 }
 
-public OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) {
-    const char *str = Text$as_c_string(text);
+public OptionalNum32_t Num32ヽparse(Text_t text, Text_t *remainder) {
+    const char *str = Textヽas_c_string(text);
     char *end = NULL;
     double d = strtod(str, &end);
     if (end > str && end[0] == '\0') {
-        if (remainder) *remainder = Text$from_str(end);
+        if (remainder) *remainder = Textヽfrom_str(end);
         else if (*end != '\0')
             return nan("none");
         return d;
@@ -224,24 +224,24 @@ public OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) {
     }
 }
 
-static bool Num32$is_none(const void *n, const TypeInfo_t *info)
+static bool Num32ヽis_none(const void *n, const TypeInfo_t *info)
 {
     (void)info;
     return isnan(*(Num32_t*)n);
 }
 
-public CONSTFUNC bool Num32$isinf(float n) { return (fpclassify(n) == FP_INFINITE); }
-public CONSTFUNC bool Num32$finite(float n) { return (fpclassify(n) != FP_INFINITE); }
-public CONSTFUNC bool Num32$isnan(float n) { return (fpclassify(n) == FP_NAN); }
+public CONSTFUNC bool Num32ヽisinf(float n) { return (fpclassify(n) == FP_INFINITE); }
+public CONSTFUNC bool Num32ヽfinite(float n) { return (fpclassify(n) != FP_INFINITE); }
+public CONSTFUNC bool Num32ヽisnan(float n) { return (fpclassify(n) == FP_NAN); }
 
-public const TypeInfo_t Num32$info = {
+public const TypeInfo_t Num32ヽinfo = {
     .size=sizeof(float),
     .align=__alignof__(float),
     .metamethods={
-        .compare=Num32$compare,
-        .equal=Num32$equal,
-        .as_text=Num32$as_text,
-        .is_none=Num32$is_none,
+        .compare=Num32ヽcompare,
+        .equal=Num32ヽequal,
+        .as_text=Num32ヽas_text,
+        .is_none=Num32ヽis_none,
     },
 };