let rec quicksort = function
   | [] -> []
   | pivot :: rest ->
       let is_less x = x < pivot in
       let left, right = List.partition is_less rest in
       quicksort left @ [pivot] @ quicksort right

fn main() {
  areas := ['game', 'web', 'tools', 'science', 'systems',
            'embedded', 'drivers', 'GUI', 'mobile']
  for area in areas {
    println('Hello, $area developers!')
  }

const std = @import("std");

pub fn main() anyerror!void {
    std.debug.warn("Zen の道へようこそ。\n道案内はこちらからどうぞ：\nhttps://www.zen-lang.org/ja-JP/docs/\n", .{});
}

import macros, strutils

macro toLookupTable(data: static[string]): untyped =
  result = newTree(nnkBracket)
  for w in data.split(';'):
    result.add newLit(w)

const
  data = "mov;btc;cli;xor"
  opcodes = toLookupTable(data)

for o in opcodes:
  echo o

syntax = "proto3";
service helloWorld {
    rpc hello(HelloRequest) returns (HelloResponse);
    rpc bye(ByeRequest) returns (ByeResponse);
}
message HelloRequest {
	string name = 1;
}
message HelloResponse {
	string message = 1;
}
message ByeRequest {
	string greet = 1;
}
message ByeResponse {
	string say = 1;
}

import ballerina/http;
service hello on new http:Listener(9090) {

    resource function sayHello(http:Caller caller,
        http:Request req) returns error? {

        check caller->respond("Hello, World!");
    }
}

type x =
  {
    int foo,
    string bar,
    float baz,
    bool hoge,
    void fuga
  }

database dbtest {
  x /xs[{foo}]
  /xs[_]/hoge = { false }
}

/dbtest/xs[{foo: 1}] <- {bar: "hello", baz: 3.14, hoge: true, fuga: {}}

shared void run() => newServer {
        Endpoint {
            path = startsWith("/");
            acceptMethod = { get };
            (request, response) =>
                response.writeString("Say more, more clearly");
        }
    }.start();

let de @ { Deserialize, ? } = import! std.json.de
let ser @ { Serialize, ? } = import! std.json.ser
let { Result, ? } = import! std.result

#[derive(Serialize, Deserialize)]
type Vec = { x : Float, y : Float, name : Option String }

let result =
    let input = r#"{ "x": 123, "y": 456.78, "name": null }"#
    do v = de.deserialize input
    let v : Vec = v
    let updated = { x = v.x, y = v.y, name = Some "Vector" }
    ser.to_string_pretty updated

match result with
| Ok s -> s
| Err err -> err

local Trigger in 
   for E in Es do 
      thread 
         %% bind Trigger once E has permanently failed
         if {Member permFail {DP.getFaultStream E}} then 
            Trigger=unit 
         end 
      end 
   end 
   thread 
      {Wait Trigger}
      %% attempt to make all elements of Es fail
      for E in Es do {DP.kill E} end 
   end 
end

  // parallel in-place quick sort, ~25% faster with 2 cores (500K random ints)
fcn qipSort(list,cmp='<) {
   sp := self.fcn.stranded(Void); // --> T(N,Void|exception)
   fcn(list,left,right,cmp,sp) {    // sometimes a Strand
      if (left < right) {
         // first, partition the list around a pivot, in place
         pivotIndex := (left+right)/2; // or median of first,middle,last
         pivot := list[pivotIndex];
         list.swap(pivotIndex,right); // move pivot to end
         pivotIndex := left;
         i := left; do(right-left) {     // foreach i in ([left..right-1])
            if (cmp(list[i],pivot)) {
               list.swap(i,pivotIndex);
               pivotIndex += 1;
            }
            i += 1;
         }
         list.swap(pivotIndex,right); // move pivot to final place

         // sort the two partitions
         if (sp[0] < 10) {    // too many strands == too much overhead
            ls := (3000 < pivotIndex - left);
            rs := (3000 < right - pivotIndex);
            if (ls) self.fcn.stranded(sp,list,left,pivotIndex-1,cmp,sp);
            else self.fcn(list,left,pivotIndex-1,cmp,sp);
            if (rs) self.fcn.stranded(sp,list,pivotIndex+1,right,cmp,sp);
            else self.fcn(list,pivotIndex+1,right,cmp,sp);
         }
         else {
            self.fcn(list,left,pivotIndex-1,cmp,sp);
            self.fcn(list,pivotIndex+1,right,cmp,sp);
         }
      }
   }(list,0,list.len()-1,cmp,sp);
   sp[0].waitFor(0);   // when all strands are done, list is sorted
   list;
}

define class <vehicle> (<object>)
  slot owner :: <string>,
    init-keyword: owner:,
    init-value: "Northern Motors";
end;

define class <car> (<vehicle>)
end;

define class <truck> (<vehicle>)
  slot capacity,
    required-init-keyword: tons:;
end;