go-python
=========

**`sbinet/go-python` only supports CPython2. CPython2 isn't supported anymore by [python.org](https://python.org). Thus, `sbinet/go-python` is now archived.**
**A possible alternative may be to use and contribute to [go-python/cpy3](https://github.com/go-python/cpy3) instead.**

[![Build Status](https://travis-ci.org/sbinet/go-python.svg?branch=master)](https://travis-ci.org/sbinet/go-python)
[![Build status](https://ci.appveyor.com/api/projects/status/n0ujg8no487a89vo/branch/master?svg=true)](https://ci.appveyor.com/project/sbinet/go-python/branch/master)
[![GoDocs](https://godocs.io/github.com/sbinet/go-python?status.svg)](https://godocs.io/github.com/sbinet/go-python)

Naive `go` bindings towards the C-API of CPython-2.

this package provides a ``go`` package named "python" under which most of the ``PyXYZ`` functions and macros of the public C-API of CPython have been exposed.

theoretically, you should be able to just look at:

  http://docs.python.org/c-api/index.html

and know what to type in your ``go`` program.


this package also provides an executable "go-python" which just loads "python" and then call ``python.Py_Main(os.Args)``.
the rational being that under such an executable, ``go`` based extensions for C-Python would be easier to implement (as this usually means calling into ``go`` from ``C`` through some rather convoluted functions hops)


## Install

With `Go 1` and the ``go`` tool, ``cgo`` packages can't pass anymore
additional ``CGO_CFLAGS`` from external programs (except `pkg-config`)
to the "fake" ``#cgo`` preprocessor directive.

``go-python`` now uses ``pkg-config`` to get the correct location of
headers and libraries.
Unfortunately, the naming convention for the ``pkg-config`` package is
not standardised across distributions and OSes, so you may have to
edit the ``cgoflags.go`` file accordingly.

```sh
 $ go get github.com/sbinet/go-python
```

If ``go get`` + ``pkg-config`` failed:

```sh
 $ cd go-python
 $ edit cgoflags.go
 $ make VERBOSE=1
```

*Note*: you'll need the proper header and `python` development environment. On Debian, you'll need to install the ``python-all-dev`` package

Documentation
-------------

Is available on ``godocs``:

 https://godocs.io/github.com/sbinet/go-python


Example:
--------

```go
package main

import "fmt"
import "github.com/sbinet/go-python"

func init() {
   err := python.Initialize()
   if err != nil {
          panic(err.Error())
   } 
}

func main() {
 	 gostr := "foo" 
	 pystr := python.PyString_FromString(gostr)
	 str := python.PyString_AsString(pystr)
	 fmt.Println("hello [", str, "]")
}
```

```sh
$ go run ./main.go
hello [ foo ]
```

TODO:
-----

 - fix handling of integers (I did a poor job at making sure everything was ok)

 - add CPython unit-tests

 - do not expose ``C.FILE`` pointer and replace it with ``os.File`` in "go-python" API

 - provide an easy way to extend go-python with ``go`` based extensions

 - think about the need (or not) to translate CPython exceptions into go panic/recover mechanism

 - use SWIG to automatically wrap the whole CPython api ?


go-python

**Mirror closed because of 2FA, now only at https://codeberg.org/anaseto/goal**

# Goal

[![pkg.go.dev](https://pkg.go.dev/badge/codeberg.org/anaseto/goal.svg)](https://pkg.go.dev/codeberg.org/anaseto/goal)
[![godocs.io](https://godocs.io/codeberg.org/anaseto/goal?status.svg)](https://godocs.io/codeberg.org/anaseto/goal)

Goal is an embeddable array programming language with a bytecode interpreter,
written in Go. It provides both a command line intepreter (that can be used in
the REPL), and a library interface. The core features are mostly there and
tested, so Goal is usable both for writing useful short scripts and playing
with the REPL. User testing and bug reports are welcome!

Like in most array programming languages, Goal's builtins vectorize operations
on immutable arrays, and encourage a functional style for control and data
transformations, supported by a simple dynamic type system with little
abstraction, and mutable variables (but no mutable values).

It's main distinctive features are as follows:

* Syntax inspired mainly from the K language, but with quite a few deviations.
  For example, backquotes produce Go-like raw strings instead of symbols,
  `rx/\s+/` is a compile-time regular expression literal, and there is
  Perl-style string interpolation. On the other side, there are no tacit
  compositions, and digraph operator verbs and adverbs are gone or done
  differently (except for global assignment with ::).
* Primitive semantics are both inspired from the
  [ngn/k](https://codeberg.org/ngn/k) variant of the K language and
  [BQN](https://mlochbaum.github.io/BQN/index.html). For example, group by,
  classify, shifts, windows, binary search and occurrence count take after
  BQN's semantics, but free-form immutable arrays, dictionaries and adverbs
  take after K.
* Unlike in typical array languages, strings are atoms, and common string
  handling functions have been integrated into the primitives, including
  regular expression functions. Primitives acting on whole strings are
  Unicode-aware (like case-folding or Unicode properties in regexps).
* Error handling makes a distinction between fatal errors (panics) and
  recoverable errors which are handled as values.
* Integrated support for csv, json, time handling, and basic math.
* Simple IO: read/write files, run commands/pipes, open filehandles.
* Easily embeddable and extensible in Go.
* Array performance is quite decent, with specialized algorithms depending on
  inputs (type, size, range), and variable liveness analysis that reduces
  cloning by reusing dead immutable arrays (in code with limited branching).
  However, it is not a goal to reach state-of-the-art (no SIMD, and no bit
  booleans, fitting integers in arrays using either uint8 or int64 elements).
+ Scalar performance is typical for a bytecode-compiled interpreter (without
  JIT), somewhat slower than a C bytecode interpreter: value representation is
  less compact than how it could be done in C, but Goal does have unboxed
  integers and floats.

If this list is not enough to satisfy your curiosity, have a look at the [why
section](https://anaseto.codeberg.page/goal/chap-FAQ.html#why) of the FAQ.  You
can also read the [Credits.md](Credits.md) to know about main inspiration
sources for the language. Last, but not least, there are some [implementation
notes](docs/Implementation.md) too.

# Install

To install the command line interpreter, first do the following:

* Install the [go compiler](https://golang.org/).
* Add `$(go env GOPATH)/bin` to your `$PATH` (for example `export PATH="$PATH:$(go env GOPATH)/bin"`).

Then you can build the intepreter with:

	go install ./cmd/goal

Alternatively, you may type `go build -o /path/to/bin/goal ./cmd/goal` to put
the resulting binary in a custom location in your $PATH.

The `goal` command should now be available. Type `goal --help` for command-line
usage.

Typing just `goal` opens the REPL. For a better experience using the REPL (to
get typical keyboard shortcuts), you can install the readline wrapper `rlwrap`
program (available as a package in most systems), and then use instead `rlwrap
goal`.

# Links

* [Goal docs](https://anaseto.codeberg.page/goal/) : work-in-progress
  documentation for Goal.
* [vim-goal](https://codeberg.org/anaseto/vim-goal) : vim files for Goal.
* [APL Farm](https://matrix.to/#/#aplfarm:matrix.org) : chat about array
  languages.

# Documentation

In addition to the work-in-progress [documentation
website](https://anaseto.codeberg.page/goal/), you might be interested in the
[Changelog](Changes.md) changes between releases. The REPL help is also
available in text form here at [docs/help.txt](docs/help.txt).

# Examples

A few short examples can be found in the `examples` and `testdata/scripts`
directory. Because the latter are used for testing, they come along an expected
result after a `/RESULT:` comment.

Also, various code generation scripts in the toplevel `scripts` directory are
written in Goal.


The Best Go Libraries For Embeddable Scripting Languages - Embedding other languages inside your go code. (2)

go-python

goal