examples: Changed the syntax to the latest one

hexaredecimal · hexaredecimal · commit 1015d010a162 · 2025-06-26T19:30:23.000+02:00
diff --git a/examples/array2.pics b/examples/array2.pics
@@ -1,23 +1,22 @@
 
-
 import std.io
 import std.array
 
-let numbers = [1,2,3]
+numbers := [1,2,3]
 
-let mapped = Array.map(numbers, |x| -> x * 2) 
+mapped := Array::map(numbers, |x| -> x * 2) 
 
-IO.println(mapped)
-IO.println(Array.join(numbers, "::"))
+IO::println(mapped)
+IO::println(Array::join(numbers, "::"))
 
-function reduce(xs=[], f, acc) =
-    when xs {
-      is [] -> acc
-      is x:rest -> reduce(rest, f, f(acc, x))
-    }
+reduce :: (xs=[], f, acc) =
+  when xs {
+		is [] -> acc
+		is x:rest -> reduce(rest, f, f(acc, x))
+	}
 
-let result = reduce(mapped, |acc, x| -> acc + x, 0) 
+result := reduce(mapped, |acc, x| -> acc + x, 0) 
 
-IO.println(Array.contains(mapped, 2))
-IO.println(Array.indexOf(mapped, 4))
+IO::println(Array::contains(mapped, 2))
+IO::println(Array::indexOf(mapped, 4))
 
diff --git a/examples/arrayfilter.pics b/examples/arrayfilter.pics
@@ -1,15 +1,15 @@
 
 import std.io
 
-function filter(xs=[], pred) =
+filter :: (xs=[], pred) =
   when xs {
     is [] -> []
     is x:rest -> 
       if pred(x) { x:filter(rest, pred) }
       else { filter(rest, pred) }
   }
 
-let nums = [1,2,3,4]
+nums := [1,2,3,4]
 
-let greater = filter(nums, |num| -> num > 2)
-IO.println(greater)
+greater := filter(nums, |num| -> num > 2)
+IO::println(greater)
diff --git a/examples/arrays.pics b/examples/arrays.pics
@@ -2,17 +2,17 @@
 import std.array
 import std.io
 
-let numbers = [1,2,3]
-let strings = ["A", "B", "C"]
+numbers := [1,2,3]
+strings := ["A", "B", "C"]
 
-let concat = Array.concat(numbers, strings)
+concat := Array::concat(numbers, strings)
 
-IO.println(concat)
-IO.println(concat.len)
+IO::println(concat)
+IO::println(concat.len)
 
-let collon_sep = Array.join(strings, ":")
+collon_sep := Array::join(strings, ":")
 
-IO.println(collon_sep)
+IO::println(collon_sep)
 
-let new = collon_sep:concat
-IO.println(new)
+new := collon_sep:concat
+IO::println(new)
diff --git a/examples/arrayzip.pics b/examples/arrayzip.pics
@@ -1,13 +1,13 @@
 
 import std.io
 
-function zip(xs=[], ys=[]) =
+zip :: (xs=[], ys=[]) =
   when [xs, ys] {
     is [[], _] -> []
     is [_, []] -> []
     is [x:xs1, y:ys1] -> [ [x, y] ] : zip(xs1, ys1)
   }
 
-IO.println(zip)
+IO::println(zip)
 
-IO.println(zip([1, 2, 3], [4, 5, 6]))
+IO::println(zip([1, 2, 3], [4, 5, 6]))
diff --git a/examples/closures.pics b/examples/closures.pics
@@ -1,20 +1,20 @@
 
 import std.io
 
-function map(xs=[], f) =
+map :: (xs=[], f) =
   when xs{
     is [] -> []
     is x:rest -> f(x) : map(rest, f)
   }
 
-let add = |a, b| -> a + b
+add := |a, b| -> a + b
 
-let inc = add(1)
+inc := add(1)
 
-let numbers = [1,2,3]
-let mapped = map(numbers, inc)
-IO.println(mapped)
+numbers := [1,2,3]
+mapped := map(numbers, inc)
+IO::println(mapped)
 
-let mapped = map(numbers, |num| -> num:numbers)
-IO.println(mapped)
+mapped := map(numbers, |num| -> num:numbers)
+IO::println(mapped)
 
diff --git a/examples/factorial.pics b/examples/factorial.pics
@@ -1,13 +1,13 @@
 
 import std.io
 
-function factorial(x=1) = 
+factorial :: (x=1) = 
   if x <= 1 { 1 } 
   else { x * factorial(x - 1) }
 
-let result = factorial(5)
-IO.println(result)
+result := factorial(5)
+IO::println(result)
 
-let result = factorial(100)
-IO.println(result)
+result := factorial(100)
+IO::println(result)
 
diff --git a/examples/fib.pics b/examples/fib.pics
diff --git a/examples/fizzbuzz.pics b/examples/fizzbuzz.pics
@@ -3,15 +3,15 @@ import std.io
 import std.array
 import std.iters
 
-let range = Array.fromRange(1, 50)
+range := Array::fromRange(1, 50)
 
-Iterators.forEach(range, |i| -> do {
+Iterators::forEach(range, |i| -> do {
 
   when ((i % 3) == 0, (i % 5) == 0) {
-    is (true, false) -> IO.println("Fizz")
-    is (false, true) -> IO.println("Buzz")
-    is (true, true) -> IO.println("FizzBuzz")
-    else -> IO.println(i)
+    is (true, false) -> IO::println("Fizz")
+    is (false, true) -> IO::println("Buzz")
+    is (true, true) -> IO::println("FizzBuzz")
+    else -> IO::println(i)
   }
 
 })
diff --git a/examples/gcd.pics b/examples/gcd.pics
@@ -1,13 +1,13 @@
 
 import std.io
 
-function gcd(a, b=0) = 
+gcd :: (a, b=0) = 
   when (a, b) {
     is (_, 0) -> a
     else -> gcd(b, a % b)
   }
 
-let result = gcd(10, 20)
+result := gcd(10, 20)
 
-IO.println(result)
+IO::println(result)
 
diff --git a/examples/hello.pics b/examples/hello.pics
@@ -1,5 +1,5 @@
 
 import std.io
 
-IO.println("Hello, world")
+IO::println("Hello, world")
 
diff --git a/examples/iter.pics b/examples/iter.pics
@@ -3,9 +3,9 @@ import std.io
 import std.array
 import std.iters
 
-let arr = Array.fromRange(1, 5)
+arr := Array::fromRange(1, 5)
 
-Iterators.forEach(arr, |item| -> do {
-  IO.println(item)
+Iterators::forEach(arr, |item| -> do {
+  IO::println(item)
 })
 
diff --git a/examples/modules.pics b/examples/modules.pics
@@ -1,23 +1,23 @@
 
 import std.io
 
-module Foo {
-	function bar() = IO.println("Foo.Bar")
+Foo :: module {
+	bar :: () = IO::println("Foo.Bar")
 }
 
-module Foo {
-	function baz() = IO.println("Foo.Baz")
+Foo :: module {
+	baz :: () = IO::println("Foo.Baz")
 }
 
-Foo.bar()
-Foo.baz()
+Foo::bar()
+Foo::baz()
 
-module Foo {
-	module Foo2 {
-		function bar2() = IO.println("Foo.Foo2.bar2")
-	m
+Foo :: module {
+	Foo2 :: module {
+		function bar2() = IO::println("Foo::Foo2::bar2")
+	}
 }
 
-IO.println(Foo.Foo2)
-Foo.Foo2.bar2()
+IO::println(Foo::Foo2)
+Foo::Foo2::bar2()
 
diff --git a/examples/rt-checks.pics b/examples/rt-checks.pics
@@ -3,23 +3,20 @@ import std.io { IO { println } }
 import std.type
 import std.result { Result }
 
-function saferDiv(x, y) = 
-	when (Type.isNumber(x), Type.isNumber(y), x, y) {
-		is (false, false, _, _) -> Result.err("both arguments are not numbers")
-		is (false, _, _, _) -> Result.err("1st argument is not a number")
-		is (_, false, _, _) -> Result.err("2nd argument is not a number")
-		is (_, _, _, 0) -> Result.err("Divide by zeror error")
-		else -> Result.ok(x / y)
+saferDiv :: (x, y) = 
+	when (Type::isNumber(x), Type::isNumber(y), x, y) {
+		is (false, false, _, _) -> Result::err("both arguments are not numbers")
+		is (false, _, _, _) -> Result::err("1st argument is not a number")
+		is (_, false, _, _) -> Result::err("2nd argument is not a number")
+		is (_, _, _, 0) -> Result::err("Divide by zero error")
+		else -> Result::ok(x / y)
 	}
 
-let res = saferDiv(50, 2)
-let err = saferDiv(50, [1])
+res := saferDiv(50, 2)
+error := saferDiv(50, [1])
 println(res)
-println(err)
+println(error)
 
-let res = saferDiv(50, 0)
-let err = saferDiv([], [1])
-println(res)
-println(err)
+println(saferDiv(20, 0))
 
 
diff --git a/examples/showcase.pics b/examples/showcase.pics
@@ -1,24 +1,23 @@
 
 // Syntax showcase
 
-import std.io
-
-// TODO: import std.io { println }
+import std.io { IO }
 
 // Variable declaration
-let n = 5 * 2
-let song = "Feel good Inc"
+n := 5 * 2
+song := "Feel good Inc"
 
 // The language supports the normal set of operators as in c.
 
 // Arrays
-let numbers = [1,2,3]
-let first = numbers.0
-let joined = first:numbers
+numbers := [1,2,3]
+first := numbers.0
+joined := first:numbers
 
 // Tuples
-let numbers = (1,2,3)
-let first = numbers.0
+numbers := (1,2,3)
+first := numbers[0]
+
 
 
 // If-Else
@@ -31,13 +30,13 @@ when numbers {
 }
 
 // Functions
-function add(x=1, y=1) = x + y
+add :: (x=1, y=1) = x + y
 
-let result = add(y=2)
-IO.println(result)
+result := add(y=2)
+IO::println(result)
 
-let answer = 10 |> add(10) |> add(10)
+answer := 10 |> add(10) |> add(10)
 
-IO.println(answer)
+IO::println(answer)
 
 
diff --git a/examples/virtual.pics b/examples/virtual.pics
@@ -0,0 +1,33 @@
+
+
+import std.io
+import std.virtual
+import std.array
+import std.iters
+
+
+getAnswer :: () = Virtual::task(|_| -> do {
+	Virtual::sleep(6000)
+	2000
+})
+
+handle := getAnswer()
+IO::println("Doing other things")
+
+add :: (x, y) = x + y
+answer := add(10, 20)
+
+IO::println(10 + " + " + 20 + " = " + answer)
+
+arr := Array::fromRange(1, 15)
+
+Iterators::forEach(arr, |value| -> do {
+	IO::println(value)
+})
+
+IO::println("Okay, now I need the result")
+result := handle.await
+
+IO::println("Yep, I found the result: " + result)
+
+
diff --git a/examples/virtual2.pics b/examples/virtual2.pics
diff --git a/examples/when.pics b/examples/when.pics

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`
`2`	`2`	`import std.io`
`3`	`3`
`4`		`-IO.println("Hello, world")`
	`4`	`+IO::println("Hello, world")`
`5`	`5`