https://github.com/likebike/go--

It's Go, but *everything* is exported (like Python).
https://github.com/likebike/go--

go golang

Last synced: 17 days ago
JSON representation

It's Go, but *everything* is exported (like Python).

• Host: GitHub
• URL: https://github.com/likebike/go--
• Owner: likebike
• License: mit
• Created: 2019-09-07T09:47:57.000Z (over 5 years ago)
• Default Branch: master
• Last Pushed: 2019-09-11T21:58:09.000Z (over 5 years ago)
• Last Synced: 2024-11-14T00:34:15.419Z (3 months ago)
• Topics: go, golang
• Language: Go
• Size: 19.7 MB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

• awesome-golang-repositories - go--

README

        
# go--

It's Go, but *everything* is exported (like Python).

This was a fun experimental fork of [Go](https://golang.org/), which I found to be extremely productive and user-friendly.  I finally decided to discontinue the experiment because `go vet` no longer worked and I didn't want to spend the time to fix it.  Also, I found an alternative workaround to solve the original problem that led me to create this fork in the first place.

Here is an example of the augmented abilities of go-- :

```

#!go/bin/go run

//^^^^^^^^^^^^^ "shebang" support enables you to run Go programs as scripts.

//              I usually like to say something like "#!/usr/bin/env go run",

//              but on Linux a shebang command can only have ONE argument, so

//              the kernel tries to run "go run" as a command, which fails.

//              (BSD and MacOSX don't have this problem.)

//              We *could* create a "go run" binary as part of Go-- to enable this

//              in a cross-platform sort of way, but for now I just use this

//              relative path.  You'll need to run from this directory.

package main

import (

    "fmt"

    "net/http"

    "encoding/json"

    "os"             // Unused imports now generate Warnings instead of Errors.

)

type T1 struct { n1,n2 int }

func                       // I'm not saying that this is actually a good way to style your function definitions...

(t T1)                     // I'm only saying that you should be allowed to do it if you want to.

crazy_func_style

(in1,in2 int)

(out1,out2 int)

{

    return 3,4

}

func main() {

    fmt.Println("\nWelcome to Go--.  Don't worry about those warnings that you see above -- they are a *feature*, not a bug!")

    fmt.Println("Go-- gives you some extra abilities, compared to normal Go:\n")

    unused:=5

    fmt.Println("    * Unused variables and imports now generate Warnings (like you see above) instead of Errors.\n")

    http.Header{}.clone(); _=http.response{}.status; http.htmlEscape("We can access everything!")

    fmt.Println("    * You can access unexported symbols.\n")

    var a,b T1; a.n1,a.n2=8,9

    bs,err:=json.Marshal(a); if err!=nil { panic(err) }

    err=json.Unmarshal(bs, &b); if err!=nil { panic(err) }

    if b.n1!=8 || b.n2!=9 { panic("json was unable to read/set unexported field!") }

    fmt.Println("    * encoding/json can un/marshal unexported fields.\n")

    if 0>1 { }  // Comments here are fine too.

    else { fmt.Println("    * More flexible whitespace in 'if' statements; `if cond {...} \\n else {...}` is now a valid syntax.\n") }

    three,four:=a.crazy_func_style(1,2); if three!=3 || four!=4 { panic("Incorrect crazy_func_style outputs!") }

    fmt.Println("    * More flexible whitespace in function definitions.\n")

    fmt.Println("    * You can use a 'shebang' line (#!...) to run your Go-- programs as scripts.\n")

    fmt.Println("Remember: with great power comes great responsiblity.  Have fun!\n")

}

```