feat: add Golang and examples

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "vendor/tree-sitter-python"]
 	path = vendor/tree-sitter-python
 	url = https://github.com/tree-sitter/tree-sitter-python
+[submodule "vendor/tree-sitter-go"]
+	path = vendor/tree-sitter-go
+	url = https://github.com/tree-sitter/tree-sitter-go

README.md

@@ -23,86 +23,211 @@ zig build
 
 ## Examples
 
-```python
+<details>
-from typing import Union
+    <summary>Python</summary>
 
-from fastapi import FastAPI
+    ```python
+    from typing import Union
 
-app = FastAPI()
+    from fastapi import FastAPI
+
+    app = FastAPI()
 
 
-@app.get("/")
+    @app.get("/")
-def read_root():
+    def read_root():
-    return {"Hello": "World"}
+        return {"Hello": "World"}
 
 
-@app.get("/items/{item_id}")
+    @app.get("/items/{item_id}")
-def read_item(item_id: int, q: Union[str, None] = None):
+    def read_item(item_id: int, q: Union[str, None] = None):
-    return {"item_id": item_id, "q": q}
+        return {"item_id": item_id, "q": q}
-```
+    ```
 
-Result:
+    Result:
 
-```
+    ```
-File: test.py
+    File: test.py
-Language: python
+    Language: python
 
-var app = FastAPI();
+    var app = FastAPI();
-func read_root() -> void;
+    func read_root() -> void;
-func read_item() -> void;
+    func read_item() -> void;
-```
+    ```
 
+</details>
 
-```zig
+<details>
-const std = @import("std");
+    <summary>Zig</summary>
 
-const root = @import("root.zig");
+    ```zig
-const E = root.E;
+    const std = @import("std");
-const P3 = root.P3;
-const Vec3 = root.Vec3;
-const Sphere = root.Sphere;
-const Ray = root.Ray;
-const Interval = root.Interval;
 
-pub const Hittable = union(enum) {
+    const root = @import("root.zig");
-    const Self = @This();
+    const E = root.E;
-    sphere: Sphere,
+    const P3 = root.P3;
+    const Vec3 = root.Vec3;
+    const Sphere = root.Sphere;
+    const Ray = root.Ray;
+    const Interval = root.Interval;
 
-    pub fn initSphere(center: [3]E, radius: E) Self {
+    pub const Hittable = union(enum) {
-        return .{ .sphere = Sphere.init(center, radius) };
+        const Self = @This();
-    }
+        sphere: Sphere,
 
-    pub fn deinit(self: Self) void {
+        pub fn initSphere(center: [3]E, radius: E) Self {
-        switch (self) {
+            return .{ .sphere = Sphere.init(center, radius) };
-            inline else => |hittable| hittable.deinit(),
         }
-    }
 
-    pub const Collision = struct {
+        pub fn deinit(self: Self) void {
-        const Inner = @This();
+            switch (self) {
-        pub const Face = enum { front, back };
+                inline else => |hittable| hittable.deinit(),
-        t: E,
+            }
-        p: P3,
+        }
-        normal: Vec3,
+
-        face: Face,
+        pub const Collision = struct {
+            const Inner = @This();
+            pub const Face = enum { front, back };
+            t: E,
+            p: P3,
+            normal: Vec3,
+            face: Face,
+        };
+
+        pub fn collisionAt(self: Self, interval: Interval, ray: *const Ray) ?Collision {
+            switch (self) {
+                inline else => |hittable| return hittable.collisionAt(interval, ray),
+            }
+        }
     };
+    ```
 
-    pub fn collisionAt(self: Self, interval: Interval, ray: *const Ray) ?Collision {
+    Result:
-        switch (self) {
+
-            inline else => |hittable| return hittable.collisionAt(interval, ray),
+    ```
-        }
+    File: /Users/bogdanbuduroiu/development/bruvduroiu/raytracing.zig/src/hittable.zig
+    Language: zig
+
+    var t;
+    var p;
+    var normal;
+    var face;
+    ```
+
+</details>
+
+<details>
+    <summary>Go</summary>
+
+    ```go
+    package batch_sliding_window
+
+    import (
+        "fmt"
+        "go.temporal.io/sdk/temporal"
+        "go.temporal.io/sdk/workflow"
+        "time"
+    )
+
+    // ProcessBatchWorkflowInput input of the ProcessBatchWorkflow.
+    // A single input structure is preferred to multiple workflow arguments to simplify backward compatible API changes.
+    type ProcessBatchWorkflowInput struct {
+        PageSize          int // Number of children started by a single sliding window workflow run
+        SlidingWindowSize int // Maximum number of children to run in parallel.
+        Partitions        int // How many sliding windows to run in parallel.
     }
-};
-```
 
-Result:
+    // ProcessBatchWorkflow sample Partitions the data set into continuous ranges.
+    // A real application can choose any other way to divide the records into multiple collections.
+    func ProcessBatchWorkflow(ctx workflow.Context, input ProcessBatchWorkflowInput) (processed int, err error) {
+        ctx = workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
+            StartToCloseTimeout: 5 * time.Second,
+        })
 
-```
+        var recordLoader *RecordLoader // RecordLoader activity reference
-File: /Users/bogdanbuduroiu/development/bruvduroiu/raytracing.zig/src/hittable.zig
+        var recordCount int
-Language: zig
+        err = workflow.ExecuteActivity(ctx, recordLoader.GetRecordCount).Get(ctx, &recordCount)
+        if err != nil {
+            return 0, err
+        }
 
-var t;
+        if input.SlidingWindowSize < input.Partitions {
-var p;
+            return 0, temporal.NewApplicationError(
-var normal;
+                "SlidingWindowSize cannot be less than number of partitions", "invalidInput")
-var face;
+        }
-```
+        partitions := divideIntoPartitions(recordCount, input.Partitions)
+        windowSizes := divideIntoPartitions(input.SlidingWindowSize, input.Partitions)
+
+        workflow.GetLogger(ctx).Info("ProcessBatchWorkflow",
+            "input", input,
+            "recordCount", recordCount,
+            "partitions", partitions,
+            "windowSizes", windowSizes)
+
+        var results []workflow.ChildWorkflowFuture
+        offset := 0
+        for i := 0; i < input.Partitions; i++ {
+            // Makes child id more user-friendly
+            childId := fmt.Sprintf("%s/%d", workflow.GetInfo(ctx).WorkflowExecution.ID, i)
+            childCtx := workflow.WithChildOptions(ctx, workflow.ChildWorkflowOptions{WorkflowID: childId})
+            // Define partition boundaries.
+            maximumPartitionOffset := offset + partitions[i]
+            if maximumPartitionOffset > recordCount {
+                maximumPartitionOffset = recordCount
+            }
+            input := SlidingWindowWorkflowInput{
+                PageSize:          input.PageSize,
+                SlidingWindowSize: windowSizes[i],
+                Offset:            offset,                 // inclusive
+                MaximumOffset:     maximumPartitionOffset, // exclusive
+            }
+            child := workflow.ExecuteChildWorkflow(childCtx, SlidingWindowWorkflow, input)
+            results = append(results, child)
+            offset += partitions[i]
+        }
+        // Waits for all child workflows to complete
+        result := 0
+        for _, partitionResult := range results {
+            var r int
+            err := partitionResult.Get(ctx, &r) // blocks until the child completion
+            if err != nil {
+                return 0, err
+            }
+            result += r
+        }
+        return result, nil
+    }
+
+    func divideIntoPartitions(number int, n int) []int {
+        base := number / n
+        remainder := number % n
+        partitions := make([]int, n)
+
+        for i := 0; i < n; i++ {
+            partitions[i] = base
+        }
+
+        for i := 0; i < remainder; i++ {
+            partitions[i] += 1
+        }
+
+        return partitions
+    }
+    ```
+
+    Result:
+
+    ```
+    File: /Users/bogdanbuduroiu/development/temporalio/samples-go/batch-
+    sliding-window/batch_workflow.go
+    Language: go
+
+    class ProcessBatchWorkflowInput {
+    };
+    var PageSize;
+    var SlidingWindowSize;
+    var Partitions;
+    func ProcessBatchWorkflow() -> void;
+    func divideIntoPartitions() -> void;
+    ```
+</details>

build.zig

@@ -80,7 +80,7 @@ pub fn build(b: *std.Build) void {
     exe.linkLibrary(tree_sitter.artifact("zig-tree-sitter"));
 
     // Build language level packages
-    const supported_langs: [3][]const u8 = .{ "c", "python", "zig" };
+    const supported_langs: [4][]const u8 = .{ "c", "python", "zig", "go" };
     const prefix = "tree-sitter-";
     inline for (supported_langs) |lang| {
         const name = comptime blk: {

src/language.zig

@@ -5,11 +5,13 @@ const Allocator = std.mem.Allocator;
 extern fn tree_sitter_zig() callconv(.C) *ts.Language;
 extern fn tree_sitter_c() callconv(.C) *ts.Language;
 extern fn tree_sitter_python() callconv(.C) *ts.Language;
+extern fn tree_sitter_go() callconv(.C) *ts.Language;
 
 pub const LanguageType = enum {
     python,
     zig,
     c,
+    go,
     unknown,
 
     pub fn fromExtension(ext: []const u8) LanguageType {
@@ -19,6 +21,8 @@ pub const LanguageType = enum {
             return .zig;
         } else if (std.mem.eql(u8, ext, ".c") or std.mem.eql(u8, ext, ".h")) {
             return .c;
+        } else if (std.mem.eql(u8, ext, ".go")) {
+            return .go;
         } else {
             return .unknown;
         }
@@ -29,6 +33,7 @@ pub const LanguageType = enum {
             .python => "python",
             .zig => "zig",
             .c => "c",
+            .go => "go",
             .unknown => "unknown",
         };
     }
@@ -38,6 +43,7 @@ pub const LanguageType = enum {
             .python => tree_sitter_python(),
             .zig => tree_sitter_zig(),
             .c => tree_sitter_c(),
+            .go => tree_sitter_go(),
             .unknown => null,
         };
     }
@@ -132,6 +138,38 @@ pub const LanguageType = enum {
             \\  (storage_class_specifier) @extern
             \\) @variable
             ,
+            .go =>
+            \\;; Capture top-level functions and struct definitions
+            \\(source_file
+            \\  (var_declaration
+            \\    (var_spec) @variable
+            \\  )
+            \\)
+            \\(source_file
+            \\  (const_declaration
+            \\    (const_spec) @variable
+            \\  )
+            \\)
+            \\(source_file
+            \\  (function_declaration) @function
+            \\)
+            \\(source_file
+            \\  (type_declaration
+            \\    (type_spec (struct_type)) @class
+            \\  )
+            \\)
+            \\(source_file
+            \\  (type_declaration
+            \\    (type_spec
+            \\      (struct_type
+            \\        (field_declaration_list
+            \\          (field_declaration) @class_variable)))
+            \\  )
+            \\)
+            \\(source_file
+            \\  (method_declaration) @method
+            \\)
+            ,
             .unknown => null,
         };
     }

vendor/tree-sitter-go

@@ -0,0 +1 @@
+Subproject commit 5e73f476efafe5c768eda19bbe877f188ded6144