borgo-lang / borgo

Borgo is a statically typed language that compiles to Go.

The Borgo Programming Language

---

I want a language for writing applications that is more expressive than Go but less complex than Rust.

Go is simple and straightforward, but I often wish it offered more type safety. Rust is very nice to work with (at least for single threaded code) but it's too broad and complex, sometimes painfully so.

Borgo is a new language that transpiles to Go. It's fully compatible with existing Go packages.

Borgo syntax is similar to Rust, with optional semi-colons.

Tutorial

Check out the online playground for a tour of the language.

You can also take a look at test files for working Borgo code:

• codegen-emit.md
• infer-expr.md
• infer-file.md

Features

Algebraic data types and pattern matching

use fmt

enum NetworkState {
    Loading,
    Failed(int),
    Success(string),
}

let msg = match state {
    NetworkState.Loading => "still loading",
    NetworkState.Failed(code) => fmt.Sprintf("Got error code: %d", code),
    NetworkState.Success(res) => res,
}

---

Option<T> instead of nil

// import packages from Go stdlib
use fmt
use os

let key = os.LookupEnv("HOME")

match key {
    Some(s) => fmt.Println("home dir:", s),
    None => fmt.Println("Not found in env"),
}

---

Result<T, E> instead of multiple return values

use fmt
use net.http

fn makeRequest() -> Result<int, error> {
    let request = http.Get("http://example.com")

    match request {
        Ok(resp) => Ok(resp.StatusCode),
        Err(err) => Err(fmt.Errorf("failed http request %w", err))
    }
}

---

Error handling with ? operator

use fmt
use io
use os

fn copyFile(src: string, dst: string) -> Result<(), error> {
    let stat = os.Stat(src)?

    if !stat.Mode().IsRegular() {
        return Err(fmt.Errorf("%s is not a regular file", src))
    }

    let source = os.Open(src)?
    defer source.Close()

    let destination = os.Create(dst)?
    defer destination.Close()

    // ignore number of bytes copied
    let _ = io.Copy(destination, source)?

    Ok(())
}

---

Guessing game example

Small game from the Rust book, implemented in Borgo.

Things to note:

• import packages from Go stdlib
• strconv.Atoi returns an Option<int>
• Reader.ReadString returns a Result<string, error> (which can be unwrapped)

use bufio
use fmt
use math.rand
use os
use strconv
use strings
use time

fn main() {
    let reader = bufio.NewReader(os.Stdin)

    let secret = rand.Intn(100) + 1

    loop {
        fmt.Println("Please input your guess.")

        let text = reader.ReadString('\n').Unwrap()
        let text = strings.TrimSpace(text)

        let guess = match strconv.Atoi(text) {
            Ok(n) => n,
            Err(_) => continue,
        }

        fmt.Println("You guessed: ", guess)

        if guess < secret {
            fmt.Println("Too small!")
        } else if guess > secret {
            fmt.Println("Too big!")
        } else {
            fmt.Println("Correct!")
            break
        }
    }
}

Running locally

Borgo is written in Rust, so you'll need cargo.

To compile all .brg files in the current folder:

$ cargo run -- build

The compiler will generate .go files, which you can run as normal:

# generate a go.mod file if needed
# $ go mod init foo
$ go run .

borgo's Issues

Functions that return single error

I was writing definitions for os/exec and stumbled upon functions that return single error.
Example:
https://pkg.go.dev/os/exec#Cmd.Run

func (c *Cmd) Run() error

Run() returns error if error happened, otherwise returns nil.
I tried wrapping error in Option. But that assumes that there is second bool return argument.
Then I tried using Result<()>, but still it assumed that there are two return arguments.

What should I use for this use case?

Hey, I've built a Dagger module

I just wanted to let you know that I've built a Dagger module for Borgo: https://daggerverse.dev/mod/github.com/sagikazarmark/daggerverse/borgo@ceb297ed12bc72ea5137dede646639f0334cf8ee

There is a test that demonstrates how it work: https://github.com/sagikazarmark/daggerverse/blob/main/borgo/tests/main.go

fun as function keyword to line up code better

Small pet peeve: I never understood why Rust (not to mention Go) didn't go with fun as the keyword for functions, so that the function name lines up with four space indentation of the code below 😊

So instead of:

fn main() {
    let reader = bufio.NewReader(os.Stdin)

    rand.Seed(time.Now().UnixNano())
    let secret = rand.Intn(100) + 1
    // ... cont ...

We'd have:

fun main() {
    let reader = bufio.NewReader(os.Stdin)

    rand.Seed(time.Now().UnixNano())
    let secret = rand.Intn(100) + 1
    // ... cont ...

Just to say how great this project is

While I'm not looking for a solution like this for my own work (I'm happy using Rust), I want to congratulate you on it. It addresses the weaknesses in Go and the design decisions are excellent.

It also fills a need for what is many times discussed on the Rust forum, which is a language like Rust that has GC and is much simpler to use, Of course, Rust people would prefer Rust semantics rather than Go semantics, but I see that as a relatively minor issue.

Of course, to make this usable there are tons of tools need, LSP, etc. I hope there are people in the Go community who are motivated to help with this.

Many compiling error ocures when running `Primary Type` example from playgroud.

./type.go:32:6: undefined: Slice_Append
./type.go:35:35: undefined: Slice_Len
./type.go:37:6: undefined: Map_new
./type.go:41:2: undefined: Map_Insert
./type.go:44:2: undefined: Map_Insert
./type.go:50:9: undefined: Tuple2

License

I notice you don't specify a license in this repository (besides a reference to UPL here) which means users have no rights to do anything at all with this code.

Can you please specify a license if any?

Generate binary

• It would be nice if Borgo compiler went a bit further and generated the compiled go code.
• Of course this would require having go toolchain installed, but IMHO would be a nice dev UX
• BTW...this project looks super cool!

I think need forked golang

generated code is too junk

Are there any plans to develop a language server?

Are there currently any plans for developing a language server, and a set of editor extensions that use the language server?

Are there any plans to release a pre-built compiler binary?

Are there currently any plans for releasing a pre-built binary of the compiler on Brew & Apt?

Can io.Reader's Read safely return Result<int>?

The definition of Read in io.Reader is currently fn Read (p: [byte]) -> Result<int>. I believe this limits it to returning only one of the number of bytes read or an error. But this does not reflect what Read does. From go's docs, Read "returns the number of bytes read (0 <= n <= len(p)) and any error encountered" (emphasis added). There is further discussion of this in several golang-nuts threads such as this one.

(Apologies if I misunderstood something here. I know more go than rust, and I ended up here thanks to an interesting-sounding link from go weekly news.)

generates code with invalid generics when calling helper functions

The following borgo code:

use fmt

struct foo<T> {
    val: T
}

impl<T> (f: foo<T>) {
    fn print() {
        printHelper(f)
    }
}

fn printHelper<T>(f: foo<T>) {
    fmt.Println(f.val)
}

fn main() {
    let f = foo{val: 5}
    f.print()
}

generates:

package main
import (
 "fmt"
)

type foo[T any] struct {
  val T
}
 func (f foo[T]) print  ()  {


 printHelper[any](f)
}
 func  printHelper [T any] (f foo[T])  {


 fmt.Println(f.val)
}
 func  main  ()  {


f := foo[int] { val: 5,  }

 f.print()
}

The issue here is that the line that reads printHelper[any](f) should read printHelper[T](f).

I can't find a way to get borgo to generate compiling Go code for this case.

Monadic chaining of calls

Is it possible to add iterators for slices so we can do pipeline like operations?
a := [1,2,3,4]
b := a | filter() | transform(f) | sum()

Add executable to cargo/brew

It would be great to add this tool to either cargo or brew (ideally both) to make it easier to install. As part of that, the compiler program should probably be renamed to just borgo

Does borgo support kubebuilder, and are there any limitations to using Borg in operatorsdk projects?

I'd be extremely interested in whether the metaprogramming concepts of kube builder 'annotations' play well with Borg. If so, I'd like to consider using in during an upcoming kubernetes operator refactor.

Fantastic project, looking forward to your success

How to import external package

borgo's importer tool can import go std package and user's package, but how to impot other external package:
in golang i can:

import "github.com/go-chi/chi/v5"

the corresponding usage in borgo:

use "github.com/go-chi/chi/v5"

or

use github.com/go-chi/chi/v5

neither works, how to import other package using borgo's importer tool, and how to use?

What about struct tags?

Interested in seeing how json parsing would work

Borgo logo proposal

I think the project is missing a logo, or mascot.

This is my proposal:

Credits to https://github.com/mkrl/misbrands

Suggestion : Get inspiration from Go+ (aka Goplus)

Here's the link to the Go+ project.

https://github.com/goplus/gop?tab=readme-ov-file

Suggestion : implement a syntax for iterators in Borgo.

One of the problems I have with Go is the absence of generators/iterators.

So my suggestion is to try to implement a syntax for iterators in Borgo.

Capture in the lambda, causes stack overflow (?)

Not sure what is the root cause of the issue, but compiling these code leads to stack overflow:

use fmt

struct Iterator<T> {
    next: fn() -> Option<T>
}

fn iter<T>(list: [T]) -> Iterator<T> {
    let mut i: int = 0
    Iterator { 
        next: || {
            if i < list.Len() {
                let x = list[i]
                i = i + 1
                Some(x)
            } else {
                None
            }
        },
    }
}


fn main() {
    let xs = [1, 2, 3, 4, 5]
    fmt.Println(iter(xs))
}

Possible causes:

1. Because I am trying to mutate i, compiler freaks out
2. Some ungodly reason that is beyond my comprehension

But, I tried to remove the logic from the lambda, and got following error

fn iter<T>(list: [T]) -> Iterator<T> {
    Iterator { 
        next: || {
            None
        },
    }
}

.\main.go:12:28: cannot use func() (T, bool) {…} (value of type func() (T, bool)) as func() Option[T] value in struct literal
when trying to compile the go code.

Here is the snippet from main.go:

type Iterator[T any] struct {
  next func () Option[T]
} 
 func  iter [T any] (list []T) Iterator[T] {


return Iterator[T] { next: func () (T, bool) {



        if make_Option_None[T]().IsSome() {
            return make_Option_None[T]().Some, true
        }
        return *new(T), false
              
},  }  
}

Naming a type "Sender" causes panic

The following code:

use fmt;

enum Sender {
  Sender
}

fn main() {
    fmt.Println("Hello")
}

causes a panic here: https://github.com/borgo-lang/borgo/blob/main/compiler/src/codegen.rs#L2061

More generally, do you want little issue reports like this at this stage of Borgo's development?