How good the produced Go code should look like?

[tmssngr]

This lisette code

fn user_choice(default_option: int, options: Slice<string>) -> int {
	loop {
		for (i, option) in options.enumerate() {
			fmt.Print(f"{i + 1} {option}")
			if i == default_option {
				fmt.Print(" [default]");
			}
			fmt.Println()
		}

		let mut input = 0
		match fmt.Scanln(&input) {
			Ok(_) => {
				if input < 1 || input > options.length() {
					continue
				}

				return input - 1
			},
			Err(_) => {
				if default_option >= 0 {
					return default_option
				}
				continue
			}
		}
	}
}

is transpiled to this Go code

func user_choice(default_option int, options []string) int {
loop_1:
	for {
		for i, option := range options {
			fmt.Printf("%d %s", i+1, option)
			if i == default_option {
				fmt.Print(" [default]")
			}
			fmt.Println()
		}
		input := 0
		ret_3, ret_4 := fmt.Scanln(&input)
		var result_5 lisette.Result[int, error]
		if ret_4 != nil {
			result_5 = lisette.MakeResultErr[int, error](ret_4)
		} else {
			result_5 = lisette.MakeResultOk[int, error](ret_3)
		}
		subject_2 := result_5
		if subject_2.Tag == lisette.ResultOk {
			if input < 1 || input > len(options) {
				continue loop_1
			}
			return input - 1
		}
		if default_option >= 0 {
			return default_option
		}
		continue loop_1
	}
	panic("unreachable")
}

Not really bad, but still leaves room for improvements, if the user needs to debug with a Go debugger:

• the loop_1: is not needed
• the first continue loop_1 can be replaced with continue, the second one can be removed
• the variable subject_2 could be replaced by result_5
• first wrapping into a Result type to immediately use the parts of it could be inlined -> improved performance (though this does not matter for this particular code)

My tiny test application which I've written in Go (215 lines) is 2.1MB large. I've reimplemented it in Lisette: the produced go file is 303 lines long and the binary is 3.2MB large.

[ivov]

All good points!

Polishing the emitted Go output is an ongoing process. I'll tackle some of these soon.

Curious about the 1.1 MB bump though. I could not reproduce it locally and the prelude doesn't explain it. Are you able to share your Go and Lis projects so I can take a deeper look?

[tmssngr]

Go:

package main

import (
	"fmt"
	"os"
	"sort"
	"strconv"
	"time"
	"go.bug.st/serial"
)


func userChoice(defaultOption int, options ...string) int {
	for {
		for i, option := range options {
			fmt.Print(i + 1)
			fmt.Print(" ")
			fmt.Print(option)
			if i == defaultOption {
				fmt.Print(" [default]")
			}
			fmt.Println()
		}

		input := 0
		_, err := fmt.Scanln(&input)
		if err != nil {
			if defaultOption >= 0 {
				return defaultOption
			}
			continue
		}

		if input < 1 || input > len(options) {
			continue
		}
		return input - 1
	}
}


func configure(defaultPort string) string {
	ports, err := serial.GetPortsList()
	if err != nil {
		fmt.Print("Error ")
		fmt.Println(err)
		return ""
	}

	if len(ports) == 0 {
		fmt.Println("No serial port found")
		return ""
	}

	sort.Slice(ports, func(a, b int) bool {
		return ports[a] < ports[b]
	})

	defaultOption := -1
	for i, port := range ports {
		if port == defaultPort {
			defaultOption = i
			break
		}
	}

	choice := userChoice(defaultOption, ports...)
	return ports[choice]
}


func determineFile(prefix string) string {
	_, err := os.Stat(prefix)
	if err != nil {
		return prefix
	}

	i := 2
	for {
		name := prefix + strconv.Itoa(i)
		_, err := os.Stat(name)
		if err != nil {
			return name
		}

		i += 1
	}
}


func receive(portName string) {
	name := determineFile("received")

	fmt.Print("Reading '")
	fmt.Print(name)
	fmt.Println("'...")

	file, err := os.Create(name)
	if err != nil {
		fmt.Print("Error opening file '")
		fmt.Print(name)
		fmt.Println("'")
		return
	}
	defer file.Close()

	mode := &serial.Mode {
		BaudRate: 4800,
		Parity: serial.NoParity,
		DataBits: 8,
		StopBits: serial.OneStopBit,
	}
	port, err := serial.Open(portName, mode)
	if err != nil {
		fmt.Print("Failed to open port ")
		fmt.Println(portName)
		return
	}
	defer port.Close()

	if err := port.ResetInputBuffer(); err != nil {
		fmt.Print("Failed to clear input buffer for port ")
		fmt.Println(portName)
		return
	}

	if err := port.SetReadTimeout(60 * time.Second); err != nil {
		fmt.Print("Failed to set timeout for port ")
		fmt.Println(portName)
		return
	}

	buffer := make([]byte, 1024)
	readOverall := 0
	for {
		read, err := port.Read(buffer)
		if err != nil {
			fmt.Print("Failed to read port ")
			fmt.Println(portName)
			return
		}

		if read == 0 {
			break
		}

		if readOverall == 0 {
			if err := port.SetReadTimeout(time.Second); err != nil {
				fmt.Print("Failed to set timeout for port ")
				fmt.Println(portName)
				return
			}
		}

		written, err := file.Write(buffer[:read])
		if written != read {
			fmt.Printf("wrote only %v though it should write %v\n", written, read)
			return
		}
		if err != nil {
			fmt.Print("Error writing file '")
			fmt.Print(name)
			fmt.Println("'")
			return
		}

		readOverall += read
	}

	fmt.Printf("Received %v bytes\n", readOverall)
}


func main() {
	port := ""
	ports, err := serial.GetPortsList()
	if err == nil && len(ports) > 0 {
		port = ports[0]
	}

	for {
		fmt.Println()

		fmt.Print("Port: ")
		defaultOption := 0
		if len(port) > 0 {
			defaultOption = 1
			fmt.Println(port)
		} else {
			fmt.Println("?")
		}
		choice := userChoice(defaultOption, "Configure", "Receive File", "Quit")
		switch choice {
		case 0:
			p := configure(port)
			if len(p) > 0 {
				port = p
			}
			continue

		case 1:
			if len(port) == 0 {
				port = configure(port)
			}
			if len(port) > 0 {
				receive(port)
			}
			continue

		default:
			fmt.Println("Bye!")
			return
		}
	}
}

Lisette:

import "go:fmt"
import "go:os"
import "go:sort"
import "go:strconv"
import "go:time"
import "go:go.bug.st/serial"

fn user_choice(default_option: int, options: Slice<string>) -> int {
	loop {
		for (i, option) in options.enumerate() {
			fmt.Print(f"{i + 1} {option}")
			if i == default_option {
				fmt.Print(" [default]");
			}
			fmt.Println()
		}

		let mut input = 0
		match fmt.Scanln(&input) {
			Ok(_) => {
				if input < 1 || input > options.length() {
					continue
				}

				return input - 1
			},
			Err(_) => {
				if default_option >= 0 {
					return default_option
				}
				continue
			}
		}
	}
}

fn configure(default_port: string) -> string {
	let ports = match serial.GetPortsList() {
		Ok(p) => p,
		Err(err) => {
			fmt.Println(f"Error getting ports: {err}")
			return ""
		}
	}

	if ports.is_empty() {
		return ""
	}

	sort.Slice(ports, |a, b| -> bool {
		ports[a] < ports[b]
	})

	let mut default_option = -1
	for (i, port) in ports.enumerate() {
		if port == default_port {
			default_option = i
			break
		}
	}

	let choice = user_choice(default_option, ports)
	ports[choice]
}

fn determine_file(prefix: string) -> string {
	if let Err(err) = os.Stat(prefix) {
		return prefix
	}

	//for i in 2.. {
	let mut i = 2
	loop {
		let name = prefix + strconv.Itoa(i)
		if let Err(err) = os.Stat(name) {
			return name
		}
		i += 1
	}
}

fn receive(port_name: string) {
	let name = determine_file("received")

	fmt.Println(f"Reading '{name}'...")

	let file = match os.Create(name) {
		Ok(f) => f,
		Err(err) => {
			fmt.Println(f"Error opening file '{name}'")
			return
		}
	}

	defer file.Close()

	let mode = &serial.Mode {
		BaudRate: 4800,
		Parity: serial.NoParity,
		DataBits: 8,
		StopBits: serial.OneStopBit,
		..
	}
	let port = match serial.Open(port_name, mode) {
		Ok(p) => p,
		Err(err) => {
			fmt.Println(f"Failed to open port {port_name}")
			return
		}
	}
	defer port.Close()

	if let Err(err) = port.ResetInputBuffer() {
		fmt.Println(f"Failed to clear input buffer for port {port_name}")
		return
	}

	if let Err(err) = port.SetReadTimeout(60 * time.Second) {
		fmt.Println(f"Failed to set timeouts for port {port_name}")
		return
	}

	//let mut buffer: [byte; 1024] = [0; 3]
	let mut buffer = Slice.new<byte>()
	let mut read_overall = 0
	loop {
		let read = match port.Read(buffer) {
			Ok(r) => r,
			Both(r, _) => r,
			Err(err) => {
				fmt.Println(f"Failed to read port {port_name}")
				return
			}
		}

		if read == 0 {
			break;
		}

		if let Err(err) = port.SetReadTimeout(time.Second) {
			fmt.Println(f"Failed to set timeouts for port {port_name}")
			return
		}

		let written = match file.Write(buffer[..read]) {
			Ok(w) => w,
			Both(w, _) => w,
			Err(err) => {
				fmt.Println("Failed to write to file '{name}'")
				return
			}
		}

		if written != read {
			fmt.Println(f"wrote only {written} though it should write {read}")
			return
		}

		read_overall += read
	}

	fmt.Println(f"Received {read_overall} bytes")
}

fn main() {
	let mut port = ""
	let ports = match serial.GetPortsList() {
		Ok(p) => p,
		Err(err) => Slice.new<string>()
	}
	if ports.length() > 0 {
		port = ports[0]
	}

	loop {
		fmt.Println()

		fmt.Print("Port ")
		let default_option = if port.length() > 0 {
			fmt.Println(port)
			1
		}
		else {
			fmt.Println("?")
			0
		}
		let choice = user_choice(default_option, ["Configure", "Receive File", "Quit"])
		match choice {
			0 => {
				let p = configure(port)
				if p.length() > 0 {
					port = p
				}
				continue
			},
			1 => {
				if port.is_empty() {
					let p = configure(port)
					if p.is_empty() {
						continue
					}
					port = p
				}
				receive(port)
				continue
			},
			_ => {
				fmt.Println("Bye!")
				return
			}
		}
	}
}

[tmssngr]

I also have it in Rust:

#![warn(clippy::pedantic)]

use serialport::available_ports;
use std::fs::File;
use std::io::{self, Write};
use std::path::Path;
use std::time::Duration;

fn user_choice<S: AsRef<str>>(default_option: i16, options: &[S]) -> i16 {
    loop {
        for (i, option) in options.iter().enumerate() {
            print!("{} {}", i + 1, option.as_ref());
            if i == default_option as usize {
                print!(" [default]");
            }
            println!();
        }

        let mut input = String::new();
        if let Err(_e) = io::stdin().read_line(&mut input) {
            continue;
        }

        input = input.trim().to_string();
        if input.is_empty() && default_option > 0 && (default_option as usize) < options.len() {
            return default_option;
        }

        let num = match input.parse::<u8>() {
            Ok(n) => n,
            Err(_e) => {
                continue;
            }
        };

        if num < 1 || num as usize > options.len() {
            continue;
        }

        return num as i16 - 1;
    }
}

fn configure(default_port: &String) -> String {
    let ports = match available_ports() {
        Ok(mut ports) => {
            ports.sort_by_key(|p| p.port_name.clone());
            ports
        }
        Err(e) => {
            eprintln!("Error getting ports {:?}", e);
            return default_port.clone();
        }
    };

    if ports.is_empty() {
        return default_port.clone();
    }

    let mut default_option: i16 = -1;
    let mut port_names: Vec<String> = Vec::new();
    for (i, port) in ports.iter().enumerate() {
        if port.port_name == *default_port {
            default_option = i as i16;
        }
        port_names.push(port.port_name.clone());
    }

    let choice = user_choice(default_option, &port_names);
    if choice < 0 || choice as usize >= port_names.len() {
        return default_port.clone();
    }
    port_names[choice as usize].clone()
}

fn determine_file(prefix: &str) -> String {
    let path = Path::new(&prefix);
    if !path.exists() {
        return prefix.to_string();
    }

    let mut i = 2;
    loop {
        let name = format!("{}{}", prefix, i);
        let path = Path::new(&name);
        if !path.exists() {
            return name;
        }
        i += 1;
    }
}

fn receive(port_name: &String) {
    let name = determine_file("received");
    println!("Reading '{}' from {}...", name, port_name);

    let mut file = match File::create(&name) {
        Ok(f) => f,
        Err(e) => {
            eprintln!("Failed to open file {}: {:?}", name, e);
            return;
        }
    };

    let mut port = match serialport::new(port_name, 4800)
        .timeout(Duration::from_secs(60))
        .open()
    {
        Ok(p) => p,
        Err(e) => {
            eprintln!("Failed to open port {}: {:?}", port_name, e);
            return;
        }
    };

    let mut buffer: Vec<u8> = vec![0; 1024];
    let mut read_overall = 0;
    loop {
        let read = match port.read(buffer.as_mut_slice()) {
            Ok(n) => n,
            Err(ref e) if e.kind() == io::ErrorKind::TimedOut => 0,
            Err(e) => {
                eprintln!("Failed to read from port {}: {:?}", port_name, e);
                return;
            }
        };

        if read == 0 {
            if let Err(e) = file.flush() {
                eprintln!("Failed to write to file {}: {:?}", name, e);
                return;
            }
            break;
        }

        if read_overall == 0
            && let Err(e) = port.set_timeout(Duration::from_secs(1))
        {
            eprintln!("Failed to set timeout for port {}: {:?}", port_name, e);
            return;
        }

        if let Err(e) = file.write_all(&buffer[..read]) {
            eprintln!("Failed to write to file {}: {:?}", name, e);
            return;
        }
        read_overall += read;
    }

    println!("Read {} bytes", read_overall);
}

fn main() {
    let mut port = match available_ports() {
        Ok(ports) => {
            if ports.is_empty() {
                String::new()
            } else {
                ports[0].port_name.clone()
            }
            //			ports.sort_by_key(|p| p.port_name.clone());
        }
        Err(e) => {
            eprintln!("{:?}", e);
            String::new()
        }
    };

    loop {
        print!("Port: ");
        let default_option = if port.len() > 0 {
            println!("{}", &port);
            1
        } else {
            println!("?");
            0
        };

        let choices = ["Configure", "Receive File", "Quit"];
        let choice = user_choice(default_option, &choices);
        match choice {
            0 => {
                let p = configure(&port);
                if p.len() > 0 {
                    port = p;
                }
            }
            1 => {
                if port.is_empty() {
                    let p = configure(&port);
                    if p.is_empty() {
                        continue;
                    }

                    port = p;
                }
                receive(&port);
            }
            _ => {
                println!("Bye!");
                return;
            }
        }
    }
}

Note, I'm no expert with Go or Rust. Hence, parts might be non-idiomatic or inefficient.

[ivov]

@tmssngr Thanks for following up.

Re: cleaner emitted Go - All but one of the points you raised are now cleaner via #772 and #780 and will be out with lisette-v0.4.4

Re: +1.1 MB binary size - Building your projects on my end I'm seeing:

• Go project, unstripped: ~3.1 MB
• Lis project, unstripped: ~3.1 MB
• Go project, stripped: ~2.1 MB
• Lis project, stripped: ~2.1 MB

So it appears you're comparing a stripped binary (your Go build) to an unstripped binary (your Lis build). lis build runs a plain go build with no strip flags, so it keeps debug info. Perhaps your go build environment (Makefile, IDE profile) is stripping debug info on your end.

To strip debug info in Lis: lis build --go-flags "-ldflags='-s -w'"