evhub / coconut Goto Github PK

Simple, elegant, Pythonic functional programming.

License: Apache License 2.0

Python 98.56% Makefile 1.44%

python functional language functional-programming functional-language programming-language coconut xonsh xontrib compiler

coconut's People

Contributors

Stargazers

Watchers

Forkers

gitter-badger raj347 thisiswei stephensong lynsei alfiyazi satishgoda skylarker chepner praba230890 leolujuyi moigagoo cortlandd chuckwondo x10an14 imoapps masasin malkarouri sitwon mmanguno vyraun tovim gitlinks rowhit yetone boscillator gdmcbain benji-york tdhopper keenhenry jonathanplatzer pyzh nwams shalokshalom kbaskett248 auscompgeek t2hhbmek iamshreeram jonathanslenders ricelang ajinkyakulkarni unexistance sollyucko nicholzk exphp-forks jcruz yggdr xoltar mng12345 mafm galtys poglesbyg capital-t-industries jithinraj artemisart dthboyd infrastrukt tarsbase programmingtips gareth001 kinkir studentiks hanaasagi zhenyulin peawyoyoyin stjordanis emuhedo m-burst bccrisan othmane-kada salusphilip dclambert nhat2008 questofiranon eindiran strong-roots-capital servicefoundation afcarl sailfish009 ebo renesugar seekingmeaning darwinz balabhaskar27 zhammami ihbrasheed silversit mbrukman shubhamlall pratibha-22 librecybernetics swipswaps raxod502 nlipsyc wombatpm clairvoyante vhutov dante381 rishav142k timgates42

coconut's Issues

Improve error messages

Include tracing information in compilation error messages.

Improve test coverage across Python versions

All the different targets should be tested with all the different --target parameters that they are supposed to support, and in cases such as for Python 3 where special syntax is supported, that should be tested.

Design a Coconut logo

Website should be rewritten to not be the readme.

Document match statements

Features to Include:

Constants
Captures
- with a variable
- with =
- multi-capture
Type checks
Data types
Tuples
- to deconstruct
- to split a tuple
- to split an iterator
Lists
- to deconstruct
- to split a list
- to split an iterator
Dicts
Sets

Allow module docstrings to be correctly passed through

Module docstrings should be automatically moved to the top of the compiled Python.

Allow iterator slicing to accept slice objects

iterobj$[0:5:-1] <=> iterobj$[slice(0, 5, -1)]

Change the match statement syntax

Use match <item> with <match> instead of match <match> in <item>. This is more standard wording.

Add a flag to enable Cython syntax

Suggested flags are -c, --cython.

Add pattern-matching to assignment

Just like sequences can be unpacked using simple assignment, most pattern-matching constructs should work as well, like dictionary unpacking.

Automatically inherit from object

Always inherit from object in all classes.

Provide an option to explicitly only support syntax from certain Python versions

Proposed usage:

$ coconut --target 2.7
$ coconut -t 2.7

Remove coconut references

It would make the compiled Python more readable if references to __coconut__ were removed.

Add a way to insert arbitrary Python code at any point

Suggested Syntax:

{| match |} = 5
name . {| data |} = 10

Check whether a match item is an iterator before it is sliced

Otherwise no checks are performed and non-iterators won't fall through.

Add a short-hand syntax for sets and frozensets

Suggested Syntax:

s{} == set()
f{1,2} == frozenset([1,2])

Should also appear in match statements.

Allow for multi-pattern matching

Suggested Syntax:

match <const> or <const> in <value>:
    <body>

Only recompile modified files

All compiled files should store a hash of the coconut code and coconut version that were used in compiling the file as a comment after the hashbang and encoding declaration. Then, when compiling files, the compiler should check if the file is already there with the same hash, and if it is, not recompile. A new flag -f or --force should be added to override this behavior and always recompile files.

Add syntax for constructing lazy list iterators

Something like this

(> x, y, z <)

should compile to something like this

(f() for f in (lambda: x, lambda: y, lambda: z))

Add custom operator definition syntax

Suggested Syntax:

def <arg> ` <op> ` <arg>:
    <body>
<arg> ` <op> ` <arg> = <body>

Add implicit partially applied operator function syntax

(< 5) => (lambda x: x < 5)
(5 +) => (lambda x: 5 + x)

Add flags to force compiling files stand-alone or part of a package

The suggested flags are -m or --module (in a package) and -a or --standalone (file).

Allow \\ passthroughs to use implicit continuation

Like so:

\\cdef f(
        x, y):
    <code>

Make --strict enforce only one way to do things

If --strict is enabled, errors should be generated on all Python syntax that Coconut intends to replace, such as non-decimal integers.

Improve Python 2/3 compatibility

Problems left to address:

different standard library
dictionary views
__unicode__ vs __str__

Add more pipe operators

Multiple pipe operator:

(1, 2) |*> func

Reverse pipe operator (and multiple reverse):

func <| 5

Write an IPython kernel for Coconut

See http://jupyter-client.readthedocs.org/en/latest/wrapperkernels.html

Use a separate process instead of the executor for running code

Instead of the globals() and locals() hacks that are currently employed, a separate process should be used to run code in the interpreter.

This should hopefully resolve execution errors in code like:

def f(x) = x
def g(x) = f(x)
f(1)

Make coconut a true superset of Python

That is, allow for the use of the lambda statement.

Add variable references in pattern matching

Proposed syntax:

x = 3
match [a, ^x] in [1, 2]:
    print("this match never succeeds")
match [x, ^x] in [1, 3]:
    print(x) # prints 1

Add a meta statement

Syntax should be

meta <lhs>:
    <body>
    <return rhs>

which should have its <body> run and then compiled to

parse(lhs + " = " + ascii(rhs))

Add combined head-tail and init-last splits

Matching should support syntax like:

[1, 2] + a + [4, 5] = l

Compile tail recursion optimization

Instead of providing a recursive decorator, recursive should be made a keyword allowed before def that compiles the function in a tail-recursively-optimized style.

Add case / match blocks

Proposed syntax:

case to_match:
    match (x, y):
        print("tuple of "+str(x)+" and "+str(y))
    match (x, x) if x:
        print("tuple of double true value "+str(x))

Enforce use of def in mathematical function definition

Enforcing the use of

def f(x) = x

over the use of

f(x) = x

would help disambiguate with

point(x, y) = p

which right now would need to be

match point(x, y) = p

as well as help solve the problem of match function definition such as

f(x is int) = x

being parsed like

point(x is int, y is int) = p

Use Abstract Base Classes for type-checking in pattern-matching

See: https://docs.python.org/3.4/library/abc.html

Add a way to define partial application functions

Proposed Syntax:

def func$(x,y):
    return x + y
def func$(x, y) = x + y
func = $(x, y) -> x + y

Should translate to:

def func(x):
    def _coconut_curried(y):
        return x + y
    return _coconut_curried
func = lambda x: lambda y: x + y

$ coconut -w lambda

$ coconut --warn lambda

Improve try/except statements

Allow commas in except statements to be translated into different errors to catch.

Use syntactical aliases for constructing special functions

Examples:

.join => __coconut__.operator.attrgetter("join")
"". => __coconut__.functools.partial(__coconut__.getattr, "")
func$ => __coconut__.functools.partial(__coconut__.functools.partial, func)

Add in-line conditionals

Proposed syntax:

x = (a if c else b)
x = (a if c)

Compiles to:

if c:
    coconut_if = a
else:
    coconut_if = b
x = coconut_if
if c:
    coconut_if = a
else:
    coconut_if = None
x = coconut_if

Add a flag to optimize compiled code

If -o or --optimize is specified, optimizations should be applied that could potentially invalidate code, such as not supporting index-by-slice and removing assert statements.

Add argument-unpacking in function definitions

This existed in Python 2 but was removed in Python 3.

evhub / coconut Goto Github PK

coconut's People

Contributors

Stargazers

Watchers

Forkers

coconut's Issues

Recommend Projects

Recommend Topics

Recommend Org