Dokumentace¶

Instalace¶

pip install coconut

conda config --add channels conda-forge
conda install coconut

Volitelné závislosti¶

Coconut má také volitelné dependence, instalovatelné zadáním

pip install coconut [název volitelné závislosti]

nebo pro instalaci více dependencí,

pip install coconut [opt_dep_1, opt_dep_2]

Úplný seznam volitelných depencencí:

• all: alias pro jupyter, watch, jobs, mypy (doporučný způsobinstalace úplné verze Coconut)
• jupyter/ipython: umožňuje použití flagu --jupyter / --ipython
• watch: umožňuje flag --watch
• jobs: umožňuje flag --jobs
• mypy: umožňuje flag mypy
• cPyparsing: výrazně urychluje kompilaci (pokud to vaše platformapodporuje) použitím [cPyparsing](https://github.com/evhub/ cpyparsing)
• tests: všechno nezbytné pro používání sestovací soupravy Coconutu
• docs: všechno nezbytné pro vytváření dokumentace Coconutu
• dev: všechno nezbytné pro vyvíjení Coconutu, včetně všech výše uvedených dependencí

Vývojářská verze¶

Případně, chcete-li si vyzkoušet poslední a nejlepší Coconut, zapište

pip install coconut-develop

což nainstaluje nejposlednější chodící verzi Coconutu z develop branch. Volitelná instalace závislostí je podporována stejným způsobem, jak popsáno výše. Více informací o aktuální vývojové sestavě najdete na development version of this documentation. Buďte varováni: coconut-develop může být nestabilní — narazíte-li na chybu, prosím ohlašte ji vytvořením nového issue.

Použití¶

coconut [-h] [-v] [-t version] [-i] [-l] [-k] [-p] [-a] [-w] [-r] [-n]
        [-d] [-q] [-s] [-f] [-c code] [-j processes] [--no-tco]
        [--minify] [--jupyter ...] [--mypy ...] [--argv ...] 
        [--tutorial] [--documentation] [--style name] 
        [--recursion-limit limit] [--verbose] [--trace]
        [source] [dest]

source          cesta k souboru coconut, který má být kompilován
dest            cílová složka pro compilované soubory (implicitně jí je zdrojový adresář)

-h, --help              show this help message and exit
-v, --version           print Coconut and Python version information
-t version, --target version
                        specify target Python version (defaults to
                        universal)
-i, --interact          force the interpreter to start (otherwise starts if no
                        other command is given) (implies --run)
-p, --package           compile source as part of a package (defaults to only
                        if source is a directory)
-a, --standalone        compile source as standalone files (defaults to only
                        if source is a single file)
-l, --line-numbers      add line number comments for ease of debugging
-k, --keep-lines        include source code in comments for ease of debugging
-w, --watch             watch a directory and recompile on changes 
-r, --run               run compiled Python (often used with --nowrite)
-n, --no-write          disable writing compiled Python
-d, --display           print compiled Python
-q, --quiet             suppress all informational output (combine with 
                        --display to write runnable code to stdout)
-s, --strict            enforce code cleanliness standards
--no-tco, --notco       disable tail call optimization                       
-c code, --code code    run Coconut passed in as a string (can also be piped
                        into stdin)
-j, --jobs processes    number of additional processes to use (defaults to 
                        0) (pass 'sys' to use machine default)
-f, --force             force overwriting of compiled Python (otherwise only
                        overwrites when source code or compilation
                        parameters change)
--minify                compress compiled Python                        
--jupyter, --ipython    run Jupyter/IPython with Coconut as the kernel (
                        remaining args passed to Jupyter)
--mypy ...              run MyPy on compiled Python (remaining args passe to
                        MyPy) (implies --package--no-tco)
--argv ...              set sys.argv to source plus remaining args for use
                        in Coconut script being run                     
--tutorial              open the Coconut tutorial in the default web browser

--style name            Pygments syntax highlighting style (or 'none' to
                        disable) (defaults to COCONUT_STYLE environment
                        variable, if it exists, otherwise 'default')
--recursion-limit limit
                        set maximum recursion depth in compiler (defaults to
                        2000)
--verbose               print verbose debug output
--trace                 print verbose parsing data (only available in
                        coconut-develop)

Skripty Coconutu¶

Ke spuštění souboru Coconut jako skriptu poskytuje Coconut příkaz

coconut-run

jako alias pro

coconut --run --quiet --target sys --argv

který se potichu zkompiluje a spustí `<source>`, předávajíc skriptu jakýkoliv dodatečný argument, napodobujíc tak práci příkazu pythonu.

`coconut-run` může být použit v řádku s shebangem Unixu pro vytvoření skriptu Coconut přidáním následujícího řádku na začátek skriptu:
```bash
#!/usr/bin/env coconut-run

Názvy zdrojových souborů¶

Zdrojové soubory používají extenze .coco (upřednostněno), .coc nebo .coconut. Soubor .coco (či .coc/.coconut) je kompilován do souboru s příponou .py. Je-li požadována jiná extenze než .py, například .pyde pro Python Processing, může být vložena před .coco a tato složená extenze bude použita místo .py. Například, name.coco bude kompilovat na name.py, zatímco name.pyde.coco bude kompilovat na name.pyde.

Kompilační režimy¶

Soubory, kompilované konzolou coconut se mohou lišit v závislosti na kompilačních parametrech. Je-li kompilována celá složka souborů (ve které bude kompilátor rekurzivně vyhledávat soubory s extenzí .coco, .coc nebo .coconut), vytvoří se soubor __coconut__.py, pro ukládání nezbytných funkcí (package mode), zatímco při kompilaci jediného souboru se nezbytné informace ukládají v záhlaví uvnitř souboru (standalone mode). Standalone mode je lepší pro jednotlivé soubory, protože se obejde bez nadbytečného importování __coconut__.py, avšak package mode je lepší pro velké pakety, protože se nemusí v každém souboru spouštět kód v záhlaví, jelikož může být jednoduše importován z __coconut__.py.

Je-li zdrojovým argumentem pro CLI konzolu soubor, provede se implicitně samostatná kompilace, zatímco je-li jím složka, provede se rekurzivní vyhledávání všech souborů .coco (nebo .coc či .coconut), pro něž se provede paketová kompilace. Coconut takto ve většině provede správnou volbu režimů. Je-li však důležité aby se nevytvářely žádné dodatečné soubory jako např. __coconut__.py, potom lze přinutit CLI konzolu aby použila určený režim použitím flagů --package (-p) a --standalone (-a).

Kompatibilní verze Pythonu¶

Protože je skladba Coconut založena na Python3, měl by kód Coconut, kompilovaný kompilátorem Coconut v univerzálním režimu (implicitní --target) běžet v libovolné verzi Pythonu >= 2.6 nebo >= 3.2.

Poznámka: Vyzkoušené implementace jsou CPython 2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6 a PyPy 2.7, 3.2.

Aby byly nativní objekty (built-ins) Coconut univerzálně přístupné pro různé verze Pythonu, přepisuje Coconut automaticky built-iny Pythonu 2 na příslušné protějšky Pythonu3. Navíc, Coconut také přepisuje některé built-iny Pythonu3 z optimalizačních důvodů. Je-li žádán přístup k původním verzím přepsaných built-inů, lze je získat s použitím prefixu py_.

Pro kompatibilitu se standardní knihovnou mapuje Coconut automaticky importy pod názvy Python3 s importy pod názvy Python2. Takto se Coconut automaticky postará o všechny moduly standardní knihovny, které byly přejmenovány z Python2 na Python3, pokud je použit pouze Python3. Ovšem, pro moduly nebo objekty, které existují pouze v Python3, neumí Coconut kompatibilitu zajistit.

Konečně, zatímco se Coconut pokusí kompilovat skladbu Python3 na jeho univerzální ekvivalent, následující konstrukty nemají žádný ekvivalent v Python2 a vyžadují specifikaci alespoň 3 před svým použitím:

• destructuring assignment with *s (use Coconut pattern-matching instead),
• the nonlocal keyword,
• exec used in a context where it must be a function,
• keyword class definition,
• tuples and lists with * unpacking or dicts with ** unpacking (requires --target 3.5),
• @ as matrix multiplication (requires --target 3.5),
• async and await statements (requires --target 3.5), and
• formatting f strings by prefixing them with f(requires --target 3.6).

Přípustné cíle¶

Je-li verze Pythonu, v níž bude kompilovaný kód běžet, známa předem, měl by být cíl určen flagem --target. Daný cíl (target) ovlivní pouze kompilovaný kód a zda je určitá syntaxe Pythonu3 (viz výše) povolena. Tam, kde se standardy skladeb pro Python3 a Python2 liší, bude skladba Coconut vždy používat skladbu Python3 pro všechny cíle. Podporované cíle jsou:

• universal (default) (will work on any of the below),
• 2, 2.6 (will work on any Python >= 2.6 but < 3),
• 2.7 (will work on any Python >= 2.7 but < 3),
• 3, 32 (will work on any Python >= 3.2),
• 3.3, 34 (will work on any Python >= 3.3),
• 3.5 (will work on any Python >= 3.5),
• 3.6 (will work on any Python >= 3.6),
• sys (chooses the specific target corresponding to the current version).

Note: Tečky jsou ve specifikacích cíle ignorovány, takže cíl 2.7 je ekvivalentní cíli 27.

Režim strict¶

Je-li povolen flag --strict (or -s), ohlásí Coconut chyby pro různé problémy stylu. Jsou jimi

• mixing of tabs and spaces (without --strict will show a Warning),
• use of from __future__ imports (without --strict will show a Warning)
• missing new line at end of file ),
• trailing whitespace at end of lines,
• semicolons at end of lines,
• use of the Python-style lambda statement,
• inheriting from object in classes (Coconut does this automatically)
• use of u to denote Unicode strings (all Coconut strings aru Unicode strings)
• use of backslash continuations (use [parenthetical continuation](# pokracovani-v-zavorkach) instead).

Navíc, --strict zneplatňuje (disables) zavrhnuté vlastnosti, činíce je zcela nedostupnými při kompilaci s flagem --strict. Doporučuje se při práci na novém projektu používat flag --strict (nebo -s) protože vám bude nápomocen při psaní čistšího kódu.

Zvýraznění syntaxe¶

Textové editory, které podporují zvýraznění syntaxe Coconut, jsou tyto:

• SublimeText: Viz sekci SublimeText níže.
• Vim: Viz coconut.vim.
• Emacs: Viz coconut-mode.
• Atom: Viz language-coconut.
• Každý editor, který podporuje Pygments (např. Spyder): Viz sekci Pygments níže.

Případně, pokud žádný z výše uvedený editorů vám nevyhovuje, můžete v Coconut pracovat jako v Pythonu. Jednoduše nastavte svůj editor tak, aby interpretoval všechny souboury .coco jako soubory Pythonu, čímž by mělo být zvýraznění vašeho kódu vyhovující.

highlight_language = "coconut"

Podpora pro IPython Jupyter¶

Dáváte-li přednost prostředí IPython (jádro Pythonu pro framework Jupyter ) před normální konzolou Pythonu, lze použít Coconut jako extenzi IPythonu nebo jádro Jupyteru.

Integrace s MyPy¶

Coconut se umí integrovat s MyPy za účelem optimální statické kontroly typů, včetně všech vestavěných nástrojů Coconut. Jednoduše zadejte --mypy abyste umožnili integraci s MyPy, ale dejte si pozor abyste to zadali jako poslední argument, protože všechny argumenty po --mypy jsou poslány do mypy, nikoliv do Coconut.

_Note: Protože optimalizace koncového volání vylučuje řádnou typovou kontrolu, --mypy ji implicitně vypíná.

Pro explicitní typovou kontrolu kódu v MyPy podporuje Coconut anotace typu funkcí v Python 3, anotace typu proměnných v Python 3.6 a dokonce vlastní vylepšenou skladbu anotace typů. Implicintě jsou všechny anotace typu kompilovány na signaturu typu, kompatibilní s Python 2, což znamená že všechny anotace chodí ve všech verzích Pythonu.

Coconut dokonce podporuje --mypy v interpretu, který inteligentně skenuje každý nový řádek kódu, číhaje na nově zavedené chyby MyPy. Na příklad:

Coconut dokonce podporuje --mypy v překladači, jenž skenuje inteligentně každý nový řádek kódu v kontextu s předchozím řádkem zda neobjeví nově zavedené chyby MyPy. Na příklad:

>>> a: str = count()[0]
<string>:14: error: Incompatible types in assignment (expression has type "int", variable has type "str")

:Note: Někdy si MyPy nebude vědět rady s jistými konstrukty Coconut, např. s adaptern. V tom případě jednoduše zadejte # type: ignore na řádek Coconut, na jehož kompilaci si MyPy stěžuje (o který řádek se jedná, zjistíte použitím flagu --line-numbers).

Lambdy¶

Coconut poskytuje jednoduchý, čistý operátor -> jako alternativu k příkazu lambda v Pythonu. Skladba s operátorem -> je (parameters) -> expression (nebo parameter -> expression pro lambdy s jedním argumentem). Operátor má stejné pořadí důležitosti jako starý příkaz, což znamená, že bude často nezbytné uzavřít lambdu do závorek a je asociativní vpravo.

Navíc, Coconut také podporuje implicitní použití operátoru -> ve formě (-> expression), jež je ekvivalentní k ((_=None) -> expression), což umožňuje použití implicitní lambdy když nejsou vyžadovány žádné argumenty nebo když je vyžadován jen jeden argument (vyjádřený znakem _).

Note: Je-li normální skladba lambdy nedostatečná, Coconut také podporuje rozšířenou skladbu lambdy ve formě příkazu lambda.

def <lambda>(arguments):
    return expression

dubsums = map((x, y) -> 2*(x+y), range(0, 10), range(10, 20))
dubsums |> list |> print

dubsums = map(lambda x, y: 2*(x+y), range(0, 10), range(10, 20))
print(list(dubsums))

Částečná aplikace¶

Coconut používá znak $ hned za názvem funkce, však před závorkou, použitou k volání funkce.

Částečná aplikace Coconutu také podporuje použití ? a by se přeskočilo částečné použití argumentu, odkládajíc použití tohoto argumentu až na volání částečtě aplikované funkce. To je důležité, chcete-li částečně aplikovat argumenty, které nejsou první v pořadí argumentů.

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

expnums = range(5) |> map$(pow$(?, 2))
expnums |> list |> print

# unlike this simple lambda, $ produces a pickleable object
expnums = map(lambda x: pow(x, 2), range(5))
print(list(expnums))

Spojovník (pipeline)¶

Coconut používá spojovníky (|) pro usměrnění průběhu aplikace funkcí. Všechny operátory mají precedenci infixových evokací a jsou levostranně asociativní. Všechny operátory také podporují 'in-place versions'. Těmito operátory jsou:

(|>)    => pipe forward
(|*>)   => multiple-argument pipe forward
(<|)    => pipe backward
(<*|)   => multiple-argument pipe backward

Navíc, všechny spojovníkové operátory podporují lambdu jako poslední argument, přesto že má lambda nižší precedenci. Takže, a |> x -> b |> c je ekvivalentní s a |> (x -> b |> c), nikoliv s a |> (x -> b) |> c.

Note: Pro vizuální rozložení operací přes několik řádek použijte parenthetical continuation.

obj |> .attribute |> .method(args) |> func$(args) |> .[index]

func(args, obj.attribute.method(args))[index]

def sq(x) = x**2
(1, 2) |*> (+) |> sq |> print

import operator
def sq(x): return x**2
print(sq(operator.add(1, 2)))

Skladba funkcí¶

Coconut má tři základní operátory pro skladbu funkcí: .., ..> a <... Jak .., tak <.. používají "zpětnou" skladbu funkcí, kdy je první funkce volána jako poslední, zatímco ..> používá "dopřednou" skladbu funkcí, kde je první funkce volaná jako první.

Spojovníkové operátory ..> a <.. mají také formu ..*> a <*.., která je ekvivalentní k operátorům |*> a <*|. Zpětné a dopředné spojovníkové operátory nemohou být použitý společně v jednom výrazu (na rozdíl od normálních spojovníků) a jeich precedence je mezi spojovníkem None a normálním spojovníkem.

Operátor .. má nižší precedenci než přístup k atributu (.), slicing ([]), atd, kromě volání funkce, vůči níž má precedenci vyšší. Takže je a.b..c.d ekvivalentní k (a.b)..(c.d), zatímco f..g(x) je ekvivalentní k (f.g)(x).

'In-place' operátory pro skladbu funkcí jsou ..=, ..>=, <..=, ..*>= a <*..=.

fog = f..g
f_into_g = f ..> g

# unlike this simple lambda, Coconut produces a pickleable object
fog = lambda *args, **kwargs: f(g(*args, **kwargs))
f_into_g = lambda *args, **kwargs: g(f(*args, **kwargs))

Řetězení¶

Coconut používá operátor :: pro řetězení iterátoru. Toto řetězení je prováděno líně - to jest tak, že argumenty se nevyhodnocují, pokud jich není zapotřebí. Tato forma má precedenci 'in-between bitwise or and infix calls'. 'In-place' operátorem je ::=.

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

def N(n=0) = (n,) :: N(n+1) # no infinite loop because :: is lazy

(range(-10, 0) :: N())$[5:15] |> list |> print

Krájení (slicing) iterátoru¶

K provedení iterátorového členění používá Coconut znak $ mezi iterátorem a označením jeho úseku. Iterátorové členění pracuje stejně jako sekvenční členění v Pythonu a vypadá stejně jako částečná aplikace, avšak s hranatymi místo kulatých závorek.

Iterátorové členění pracuje stejně jako sekvenční členění, včetně podpory negativních indexů a úseků (slices) a podpory pro objekty úseků stejně jako u normálního členění. Iterátorové členění však nezaručuje, že bude zachován původní iterátor (pro jeho zachování použijte funkcitee nebo reiterable).

Iterátorové členění v Coconut je velmi podobné itertools.islice v Pythonu, avšak na rozdíl od itertools.islice, podporuje iterátorové členění negativní index a přednostně použije __getitem__ objektu, pokud existuje. Iterátorové členění je také optimalizované pro práci s objekty map, zip, range a count, počítaje pouze ty prvky, které jsou nezbytné pro vynětí žádaného úseku.

map((x)->x*2, range(10**100))$[-1] |> print

None Coalescing¶

Coconut poskytuje označení ?? pro operátor none-coalescing (none-sloučení), podobný operátoru null-coalescing ?? v C#. Operátor none-coalescing vyhodnocuje svůj levý operand, nemá-li hodnotu None, v opačném případě svůj pravý operand. Tento operátor také vyjadřuje zkratku, spočívající v tom, že když jeho levý operand není None, nevyhodnocuje pravý operand. None-coalescing má precedenci mezi voláním infixové funkce a spojovníkem a je asociativní vlevo. Operátor in-place má označení ??=.

Coconut také umožňuje použití jediného znaku ? před přístupem k atributu, při volání funkce, částečné aplikaci a při (iterátorovém) indexování pro (zkratkovité) upuštění od vyhodnocení zbytku, pokud dosavadní vyhodnocení má hodnotu None. Tudíž, a?.b je ekvivalentní k a.b if a is not None else a.

could_be_none() ?? calculate_default_value()
could_be_none()?.attr[index].method()

(lambda result: result if result is not None else
 calculate_default_value())(could_be_none())
(lambda result: None if result is None else
 result.attr[index].method())(could_be_none())

Alternativy Unicode¶

Coconut podporuje alternativy Unicodu pro různé operátové symboly. Alternativy jsou poměrně nápovědné, se záměrem reflektovat vzhled nebo účel originálního symbolu.

→ (\u2192)                  => "->"
↦ (\u21a6)                  => "|>"
*↦ (*\u21a6)                => "|*>"
↤ (\u21a4)                  => "<|"
↤* (\u21a4*)                => "<*|"
× (\xd7)                    => "*"
↑ (\u2191)                  => "**"
÷ (\xf7)                    => "/"
÷/ (\xf7/)                  => "//"
∘ (\u2218)                  => ".."
∘> (\u2218>)                => "..>"
<∘ (<\u2218)                => "<.."
∘*> (\u2218*>)              => "..*>"
<*∘ (<*\u2218)              => "<*.."
− (\u2212)                  => "-" (only subtraction)
⁻ (\u207b)                  => "-" (only negation)
¬ (\xac)                    => "~"
≠ (\u2260) or ¬= (\xac=)    => "!="
≤ (\u2264)                  => "<="
≥ (\u2265)                  => ">="
∧ (\u2227) or ∩ (\u2229)    => "&"
∨ (\u2228) or ∪ (\u222a)    => "|"
⊻ (\u22bb) or ⊕ (\u2295)    => "^"
« (\xab)                    => "<<"
» (\xbb)                    => ">>"
… (\u2026)                  => "..."
⋅ (\u22c5)                  => "@" (only matrix multiplication)

data¶

Klíčové slovo data se používá k vytvoření neměnitelných algebraických datových typů s nativní podporou pro rozkladný (destructuring) pattern-matching a fmap.

Syntaxe datového bloku data je něco mezi syntaxí pro funkce a syntaxí pro třídy. První řádek vypadá jako definice funkce, zatímco zbytek těla připomíná třídu, obvykle obsahující definice metod. Je to tak proto, že zatímco blok data vlastně v Pythonu končí jako třída, Coconut automatický vytváří specielní, neměnitelný konstruktor, založený na daných argumentech.

Deklarace datového typu vypadá takto:

data <name>(<args>) [from <inherits>]:
    <body>

<name> je název nového datového typu, <args> jsou argumenty jeho konstruktoru stejně jako názvy jeho atributů, <body> obsahuje metody datového typu a nepovinně obsahuje libovolnou bázovou třídu.

Coconut připouští aby datová pole v <args> měla přiřazené implicitní hodnoty a anotace typu a podporuje hvězdičkové parametry na konci, pro posbírání extra argumentů.

Konstruktory pro datové typy musí být vytvářeny s použitím metody __new__ místo __init__. Pro snadnější psaní metod __new__ poskytuje Coconut vestavěnou funkci makedata.

Subtřídy datových typů lze snadno vytvořit jejich děděním v jiné deklaraci datového typu nebo v normální třídě Pythonu. Použije-li se normální příkaz class, vytvoření nové neměnitelné subtřídy vyžaduje přidání řádku

__slots__ = ()

do těla subtřídy před definicemi metod nebo atributů.

data vector2(x:int=0, y:int=0):
    def __abs__(self):
        return (self.x**2 + self.y**2)**.5

v = vector2(3, 4)
v |> print  # all data types come with a built-in __repr__
v |> abs |> print
v.x = 2  # this will fail because data objects are immutable
vector2() |> print

data Empty()
data Leaf(n)
data Node(l, r)

def size(Empty()) = 0

@addpattern(size)
def size(Leaf(n)) = 1

@addpattern(size)
def size(Node(l, r)) = size(l) + size(r)

size(Node(Empty(), Leaf(10))) == 1

data vector(*pts):
    """Immutable arbitrary-length vector."""

    def __abs__(self) =
        self.pts |> map$(pow$(?, 2)) |> sum |> pow$(?, 0.5)

    def __add__(self, other) =
        vector(*other_pts) = other
        assert len(other_pts) == len(self.pts)
        map((+), self.pts, other_pts) |*> vector

    def __neg__(self) =
        self.pts |> map$((-)) |*> vector

    def __sub__(self, other) =
        self + -other

match¶

Coconut poskytuje plnohodotné, funkcionální pattern-matching prostřednictvím svých příkazů match.

match <pattern> in <value> [if <cond>]:
    <body>
[else:
    <body>]

pattern ::= (
    "(" pattern ")"                 # závorky
    | "None" | "True" | "False"     # konstanty 
    | "=" NAME                      # ověření (checks)
    | NUMBER                        # čísla
    | STRING                        # řetězce
    | [pattern "as"] NAME           # capture
    | NAME "(" patterns ")"         # datové typy
    | pattern "is" exprs            # type-checking
    | pattern "and" pattern         # match all
    | pattern "or" pattern          # match any
    | "{" pattern_pairs             # dictionaries
        ["," "**" NAME] "}"
    | ["s"] "{" pattern_consts "}"  # sets  
    | "(" patterns ")"              # sekvence mohou mít formu entice
    | "[" patterns "]"              #  nebo formu seznamu
    | "(|" patterns "|)"            # líné seznamy
    | "{" pattern_pairs "}"         # slovníky
    | ["s"] "{" pattern_consts "}"  # sety
    | ("(" | "[")                   # star splits
        patterns,
        "*" middle,
        patterns
      (")" | "]")                   
    | (                             # head-tail splits
        "(" patterns ")"
        | "[" patterns "]"
      ) "+" pattern
    | pattern "+" (                 # init-last splits
        "(" patterns ")"
        | "[" patterns "]"
      )
    | (                             # head-last splits
        "(" patterns ")"
        | "[" patterns "]"
      ) "+" pattern "+" (
        "(" patterns ")"                # this match must be the same
        | "[" patterns "]"              #  construct as the first match
      )
    | (                             # iterator splits
        "(" patterns ")"
        | "[" patterns "]"
        | "(|" patterns "|)"
      ) "::" pattern
    | ([STRING "+"] NAME            # complex string matching
        ["+" STRING]) 
    )

def factorial(value):
    match 0 in value:
        return 1
    else: match n is int in value if n > 0: # possible because of Coconut's
        return n * factorial(n-1)           #   enhanced else statements
    else:
        raise TypeError("invalid argument to factorial of: "+repr(value))

3 |> factorial |> print

data point(x, y):
    def transform(self, other):         # konstruktor
        match point(x, y) in other:
            return point(self.x + x, self.y + y)
        else:
            raise TypeError("arg to transform must be a point")
    def __eq__(self, other):            # konstruktor
        match point(=self.x, =self.y) in other:
            return True
        else:
            return False

point(1,2) |> point(3,4).transform |> print
point(1,2) |> point(1,2).__eq__ |> print

data Empty()
data Leaf(n)
data Node(l, r)
Tree = (Empty, Leaf, Node)  # type union

def depth(Tree()) = 0

@addpattern(depth)
def depth(Tree(n)) = 1

@addpattern(depth)
def depth(Tree(l, r)) = 1 + max([depth(l), depth(r)])

Empty() |> depth |> print                                 
Leaf(5) |> depth |> print                                 
Node(Leaf(2), Node(Empty(), Leaf(3))) |> depth |> print   

def duplicate_first([x] + xs as l) =
    [x] + l

[1,2,3] |> duplicate_first |> print

def sieve([head] :: tail) = 
    [head] :: sieve(n for n in tail if n % head)

@addpattern(sieve)
def sieve((||)) = []

case¶

Příkaz case je rozšíření příkazu match pro potřebu opakovaného použití příkazů match vůči stejné hodnotě. Na rozdíl od osamělých příkazů match může uvnitř bloku case být úspěšný pouze jeden příkaz match. Obecnější shody (matches) mají být uvedeny pod konkretnějšími shodami.

Každý vzorek v bloku case je porovnáván, dokud není nalezena shoda. Poté se provede příslušné tělo a blok je ukončen. Skladba pro bloky case je

case <value>:
    match <pattern> [if <cond>]:
        <body>
    match <pattern> [if <cond>]:
        <body>
    ...
[else:
    <body>]

kde <pattern> je jakýkoli vzorek pro hledání shody, <value> je porovnávaná položka, <cond> je volitelná kontrola a <body> je kód, který se provede při úspěchu záhlaví. Všimněte si nepřítomnosti in v příkazech match.

def classify_sequence(value):
    out = ""        # unlike with normal matches, only one of the patterns
    case value:     #  will match, and out will only get appended to once
        match ():
            out += "empty"
        match (_,):
            out += "singleton"
        match (x,x):
            out += "duplicate pair of "+str(x)
        match (_,_):
            out += "pair"
        match _ is (tuple, list):
            out += "sequence"
    else:
        raise TypeError()
    return out

[] |> classify_sequence |> print
() |> classify_sequence |> print
[1] |> classify_sequence |> print
(1,1) |> classify_sequence |> print
(1,2) |> classify_sequence |> print
(1,1,1) |> classify_sequence |> print

where¶

Příkaz where je velmi přímočarý s touto syntaxí:

<stmt> where:
    <body>

kde <body> se skládá pouze z příkazů přiřazení. Příkaz where pouze provede zadaná přiřazení v <body> a potom vyhodnotí výchozí <stmt>.

c = a + b where:
    a = 1
    b = 2

a = 1
b = 2
c = a + b

Backslash-Escaping¶

Klíčová slova data, match, case, async (keyword in Python 3.5) a await (keyword in Python 3.5) jsou v Coconut rovněž platná jména proměnných. I když Coconut umí tyto dva případy použití rozlišit, je možné pro zvýraznění použít před takovýmto názvem proměnné zpětné lomítko.

\data = 5
print(\data)

data = 5
print(data)

Příkaz lambda¶

Skladba příkazu lambda je rozšířením normální skladby lambda pro podporu příkazů, nikoliv pouze výrazů.

Skadba pro příkaz lambda je:

def (arguments) -> statement; statement; ...

kde statement může být příkaz přiřazení nebo keyword statement. Je-li poslední statement (nenásledovaný středníkem) výrazem, je automaticky vrácen.

Příkazy lambda rovněž podporují implicitní skladbu lambda, u níž je při vypuštění argumentů, jako v def -> _, předpokládán výraz def (_=None) -> _.

L |> map$(def (x) -> y = 1 / x; y*(1 - y))

def _lambda(x):
    y = 1 / x
    return y*(1 - y)
map(_lambda, L)

Líné seznamy¶

Coconut podporuje vytváření líných seznamů (lazy lists), jejichž obsah je považován za iterátor a není vyhodnocen, dokud není zapotřebí. Líné seznamy (lazy lists) se v Coconut vytvářejí jednoduše uzavřením čárkami odděleného výčtu do specielních závorek (| a |) (takzvaných "banana brackets") místo do [ a ] u seznamů nebo do ( a ) u entic.

Líné seznamy používají ke zlenivění stejný mechanizmus jako u iterátorového řetězení a tudíž je líný seznam (| x, y |) ekvivalentní výrazu iterátorového řetězení (x,) :: (y,), byť líný seznam nevytváří mezilehlé entice.

(| print("hello,"), print("world!") |) |> consume

Implicitní částečná aplikace¶

Coconut podporuje řadu různých skladebných aliasů pro obecné případy částečné aplikace. Jsou to:

.attr           =>      operator.attrgetter("attr")
.method(args)   =>      operator.methodcaller("method", args)
obj.            =>      getattr$(obj)
func$           =>      ($)$(func)
seq[]           =>      operator.getitem$(seq)
iter$[]         =>      # the equivalent of seq[] for iterators
.[a:b:c]        =>      operator.itemgetter(slice(a, b, c))
.$[a:b:c]       =>      # the equivalent of .[a:b:c] for iterators

1 |> "123"[]
mod$ <| 5 <| 3

"123"[1]
mod(5, 3)

Operátorové funkce¶

Coconut používá jednoduchou zkratku pro vyjádření operátorové funkce: obklopení operátoru kulatými závorkami. Podobně jako u komprehencí iterátoru, je-li operátorová funkce jediným argumentem funkce, mohou závorky pro volání funkce sloužit také jako závorky operátorové funkce.

(|>)        => # pipe forward
(|*>)       => # multi-arg pipe forward
(<|)        => # pipe backward
(<*|)       => # multi-arg pipe backward
(..), (<..) => # backward function composition
(..>)       => # forward function composition
(<*..)      => # multi-arg backward function composition
(..*>)      => # multi-arg forward function composition
(.)         => (getattr)
(::)        => (itertools.chain)  # will not evaluate its arguments lazily
($)         => (functools.partial)
($[])       => # iterator slicing operator
(+)         => (operator.add)
(-)         => # 1 arg: operator.neg, 2 args: operator.sub
(*)         => (operator.mul)
(**)        => (operator.pow)
(/)         => (operator.truediv)
(//)        => (operator.floordiv)
(%)         => (operator.mod)
(&)         => (operator.and_)
(^)         => (operator.xor)
(|)         => (operator.or_)
(<<)        => (operator.lshift)
(>>)        => (operator.rshift)
(<)         => (operator.lt)
(>)         => (operator.gt)
(==)        => (operator.eq)
(<=)        => (operator.le)
(>=)        => (operator.ge)
(!=)        => (operator.ne)
(~)         => (operator.inv)
(@)         => (operator.matmul)
(not)       => (operator.not_)
(and)       => # boolean and
(or)        => # boolean or
(is)        => (operator.is_)
(in)        => (operator.contains)

(range(0, 5), range(5, 10)) |*> map$(+) |> list |> print

import operator
print(list(map(operator.add, range(0, 5), range(5, 10))))

Vylepšené anotace typu¶

Protože je syntaxe Coconutu nadmnožinou syntaxe Python3, podporuje sladbu anotace typu Pythonu 3 a skladbu anotace proměnné typu Pythonu 3.6. Implicitně kompiluje Coconut všechny anotace typu na typové komentáře, kompatibilní s Python 2. Chcete-li zachovat anotace typu, zadejte flag --target, který je podporuje.

Protože ne všechny podporované verze Pyhonu podporují modul typing, poskytuje Coconut vestavěnou proceduru TYPE_CHECKING pro zakrytí importů typing a definicí TypeVar před vyhodnocením při runtime. Kromě toho při kompilaci anotace typů do syntaxe Python3, zabalí Coconut tyto anotace do řetězců aby je uchráníl před vyhodnocením při runtime.

Navíc, Coconut přidává speciální syntaxi pro zjednodušení zápisu anotací. Uvnitř anotace typu zachází Coconut s některými konstrukty odlišně, kompilujíc je na anotaci typu místo na to, co by normálně představovaly. Konkrétně, Coconat používá následující transformace:

<type>?
    => typing.Optional[<type>]
<type>[]
    => typing.Sequence[<type>]
<type>$[]
    => typing.Iterable[<type>]
() -> <ret>
    => typing.Callable[[], <ret>]
<arg> -> <ret>
    => typing.Callable[[<arg>], <ret>]
(<args>) -> <ret>
    => typing.Callable[[<args>], <ret>]
-> <ret>
    => typing.Callable[..., <ret>]

kde typing je standardní modul Pythonu 3.5.

def int_map(
    f: int -> int,
    xs: int[],
) -> int[] =
    xs |> map$(f) |> list

import typing  # unlike this typing import, Coconut produces universal code
def int_map(
    f,  # type: typing.Callable[[int], int]
    xs,  # type: typing.Sequence[int]
):
    # type: (...) -> typing.Sequence[int]
    return list(map(f, xs))

Literály setu¶

Coconut umožňuje předsadit písmeno s před literály setu. Byť to ve většině případů nedělá nic, v případě prázdného setu to indikuje, že se jedná o set a nikoliv o dictionary. Spojení s{} informuje Coconut, že jde o prázdný set a nikoli o prázdný slovník. Spojení f{} generuje frozenset.

empty_frozen_set = f{}

empty_frozen_set = frozenset()

Imaginární literály¶

Jako doplněk k notaci imaginárních literálů<num>j nebo <num>J v Pythonu, podporuje Coconut také notace <num>i nebo <num>I pro zlepšení čitelnosti imaginárních literálů při použití v matematickém kontextu.

imagnumber ::= (floatnumber | intpart) ("j" | "J" | "i" | "I")

3.14i   10.i    10i     .001i   1e100i  3.14e-10i

3 + 4i |> abs |> print

print(abs(3 + 4j))

Optimalizace koncového volání¶

Coconut provede automatickou optimalizaci a eliminaci koncové rekurze u každé funkce, která vyhoví následujícím kriteriím:

1. musí přímo vrátit (s použitím buď return nebo přiřazovací funkce) volání sama sebe (eliminace koncového volání - nejúčinnější optimalizace) nebo jiné funkce (optimalizace koncového volání).
2. nesmí to být generátor (používající yield) nebo asynchronní funkce (používajícíasync).

Note: Optimalizace koncového voláníí (byť ne eliminace koncové rekurze) pracuje i pro 1) vzájemnou rekurzi a 2) porovnávací (pattern-matching) funkce, rozdělené do několika definicí s pouožitím addpattern.

Setkáte-li se s RuntimeError v souvislosti s maximální hloubkou rekurze, je velmi vhodné přepsat svou funkci aby vyhověla výše uvedenému kriteriu pro optimalizaci koncovým voláním nebo odpovídajícímu kriteriu pro recursive_iterator, obojí by mělo takové chybě zabránit.

Note: Optimalizace koncového volání (byť ne eliminace koncové rekurze) se vypne, zadáte-li flag --no-tco, což je užitečné, máte-li potíže se čtením svých tracebacks a potřebujete maximální výkon.

# na rozdíl od Pythonu, tato funkce nikdy nedospěje k chybě maximální hloubky rekurze
def factorial(n, acc=1):
    case n:
        match 0:
            return acc
        match _ is int if n > 0:
            return factorial(n-1, acc*n)

# unlike in Python, neither of these functions will ever hit a maximum recursion depth error
def is_even(0) = True
@addpattern(is_even)
def is_even(n is int if n > 0) = is_odd(n-1)

def is_odd(0) = False
@addpattern(is_odd)
def is_odd(n is int if n > 0) = is_even(n-1)

Přiřazovací funkce¶

Coconut umožňuje definování přiřazovací funkce tak, aby automaticky vrátila poslední řádek těla funkce. Přiřazovací funkce je vyjádřena náhradou = za :, takže složení přiřazovací funkce je buď

def <name>(<args>) = <expr>

pro jednořádkovou funkci nebo

def <name>(<args>) =
    <stmts>
    <expr>

pro víceřádkovou funkci, kde <name> je název funkce, <args> jsou argumenty funkce, <stmts> jsou přípustné příkazy a <expr> je hodnota, kterou má funkce vrátit.

Note: Definice přiřazovací funkce může být kombinována s definicí infixové a/nebo porovnávací (pattern-matching) funkce.

def binexp(x) = 2**x
5 |> binexp |> print

def binexp(x): return 2**x
print(binexp(5))

Funkce pro pattern matching¶

Tyto funkce Coconutu jsou normální funkce, kde argumenty jsou vzory k porovnávání, místo proměnných pro přiřazení hodnot. Skladba definice porovnávací (pattern-matching) funkce je

[match] def <name>(<arg>, <arg>, ... [if <cond>]):
    <body>

where <arg> je definován jako

[*|**] <pattern> [= <default>]

kde <name> je název funkce, <cond> je nepovinná dodatečná kontrola, <body> je tělo funkce, <pattern> je definován příkazem match a <default> je volitelná implicitní hodnota, není-li žádný argument zadán. Klíčové slovo match na začátku je nepovinné ale je někdy nezbytné pro odlišení definice porovnávací funkce od normální definice funkce, která má vždy přednost.

Je-li <pattern> jméno proměnné (přímo nebo s <as>), podporuje výsledná porovnávací funkce klíčové argumenty stejného jména. Jestliže provedení porovnávací funkce selže, vyvolá objekt MatchError, stejně jako rozložené přiřazení.

Note: Definice porovnávací funkce může být kombinována s definicí přiřazovací a/nebo infixové funkce.

def last_two(_ + [a, b]):
    return a, b
def xydict_to_xytuple({"x":x is int, "y":y is int}):
    return x, y

range(5) |> last_two |> print
{"x":1, "y":2} |> xydict_to_xytuple |> print

Infixové funkce¶

Coconut umožňuje infixové volání funkce, kde je výraz, vyhodnocovaný na funkci, obklopen zpětnými apostrofy; argumenty mohou být uvedeny před nebo za funkcí. Infixové volání má prioritu mezi 'chaining and None-coalescing' (řetězením a sloučením) a je asociativní vlevo.

Coconut také podporuje definování jednodušší infixové funkce:

def <arg> `<name>` <arg>:
    <body>

kde <name> je název funkce, <arg> jsou parametry funkce a <body> je tělo funkce. Obsahuje-li <arg> implicitní hodnotu, musí být uvedena v závorkách.

Note: Definici infixové funkce lze kombinovat s definicí přířazovací a/nebo porovnávací (pattern-matching) funkce.

def a `mod` b = a % b
(x `mod` 2) `print`

def mod(a, b): return a % b
print(mod(x, 2))

Definice funkce s tečkami¶

Coconut umožňuje definovat funkci s použitím vytečkovaného jména pro přiřazení funkce jako methody objektu, jak je specifikováno v PEP 542.

def MyClass.my_method(self):
    ...

def my_method(self):
    ...
MyClass.my_method = my_method

Rozkladné přiřazení¶

Coconut podporuje výrazně zlepšené rozkladné přiřazení (destructuring assignment), podobné rozkládání entice/seznamu v Pythonu. Skladba rozkladného přiřazení je

[match] <pattern> = <value>

kde <value> je libovolný výraz a <pattern> je definován příkazem match. Klíčové slovo match na začátku je nepovinné ale je někdy nezbytné pro odlišení rozloženého přiřazení od normálního přiřazení, které má vždy přednost. Rozložené přiřazení v Coconut je ekvivalentní příkazu match, jehož skladba je:

match <pattern> in <value>:
    pass
else:
    err = MatchError(<error message>)
    err.pattern = "<pattern>"
    err.value = <value>
    raise err

Selže-li provádění rozkladného přiřazení, potom místo pokračování jako při selhání u bloku match, je evokován objekt MatchError, popisující selhání.

def last_two(l):
    _ + [a, b] = l
    return a, b

[0,1,2,3] |> last_two |> print

Dekorátory¶

Narozdíl od Pythonu, který v dekorátoru podporuje pouze jedinou proměnnou nebo volání funkce, podporuje Coconut libovolný výraz.

@ wrapper1 .. wrapper2 $(arg)
def func(x) = x**2

def wrapper(func):
    return wrapper1(wrapper2(arg, func))
@wrapper
def func(x):
    return x**2

Zanořování příkazů¶

Coconut podporuje vnořování složených příkazů na témže řádku. To umožňuje spojování příkazů match a if, stejně jako složené příkazy try.

if invalid(input_list):
    raise Exception()
else: match [head] + tail in input_list:
    print(head, tail)
else:
    print(input_list)

from collections.abc import Sequence
if invalid(input_list):
    raise Exception()
elif isinstance(input_list, Sequence):
    head, tail = inputlist[0], inputlist[1:]
    print(head, tail)
else:
    print(input_list)

Příkazy except¶

Python 3 vyžaduje, že mají-li být odchyceny víceré výjimky, musí být umístěny v uvozovkách aby se znemožnilo použití čárky místo as v Python 2. Coconut umožňuje čárky ve výjimkových příkazech za účelem odchycení vícerých výjimek bez použití uvozovek, protože - stejně jako v Python3 - od as se vždy požaduje připojit výjimku ke jménu.

try:
    unsafe_func(arg)
except SyntaxError, ValueError as err:
    handle(err)

try:
    unsafe_func(arg)
except (SyntaxError, ValueError) as err:
    handle(err)

Implicitní pass¶

Coconut umožňuje jednoduchý zápis class name(base) a data name(args) jako aliasy pro class name(base): pass a data name(args): pass.

class Tree
data Empty from Tree
data Leaf(item) from Tree
data Node(left, right) from Tree

### In-line `global` a `nonlocal` přiřazení

Coconut umožňuje použití slov `global` nebo `nonlocal` před přiřazením k proměnné nebo k seznamu proměnných, činíce tak přiřazení `globální` případně `nelokální`.

##### Příklad

**Coconut:**
```coconut
global state_a, state_b = 10, 100

global state_a, state_b; state_a, state_b = 10, 100

Průchod kódu¶

Kvůli kompatibilitě s jinými variantami Pythonu, jako je Cython nebo Mython, podporuje Coconut schopnost protáhnout inertním způsobem libovolný kód kompilátorem. Cokoli umístěného mezi \( a \) projde netečně kompilátorem, stejně jako řádek, začínající \\, umožňující navíc následnou indentaci.

\\cdef f(x):
    return x |> g

cdef f(x):
    return g(x)

Vylepšené závorkové pokračování¶

Protože je syntaxe Coconut nadmnožinou syntaxe Python 3, podporuje Cooconut stejnou formu pokračování řádku jako Python. To znamená, že lze použít jak pokračování se zpětným lomítkem nebo implikované pokračování uvnitř kulatých, hranatých či složených závorek.

V Pythonu je ovšem několik případů (např. víceré příkazy with), kde lze použít pouze pokračování se zpětným lomítkem. Ve všech těchto případech podporuje Coconut i závorkové pokračování.

Podporu univerzálního použití závorkového pokračování povoluje konvence PEP 8 :

Upřednostňovaný způsob ukončování dlouhých řádků je implikované pokračování uvnitř kulatých, hranatých či složených závorek. Dlouhé řádky mohou být uvnitř závorek rozděleny do více kratších řádků. Tento způsob má přednost před používáním zpětných lomítek pro pokračování řádků.

Note: Použití flagu --strict vyloučí použití zpětných lomítek.

with (open('/path/to/some/file/you/want/to/read') as file_1,
      open('/path/to/some/file/being/written', 'w') as file_2):
    file_2.write(file_1.read())

# split into two with statements for Python 2.6 compatibility
with open('/path/to/some/file/you/want/to/read') as file_1:
    with open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())

Vylepšené vestavěné funkce¶

Objekty map, zip, filter, reversed a enumerate jsou vylepšené verze svých ekvivalentů v Pythonu, které podporují procedury reversed, repr, optimalizované (a iterátorové) krájení (slicing), len (vše až na filter) a mají přidané atributy, jež mohou subtříty použít pro přístup původním argumentům objektu:

• map: _func, _iters
• zip: _iters
• filter: _func, _iter
• reversed: _iter
• enumerate: _iter, _start

map((+), range(5), range(6)) |> len |> print
range(10) |> filter$((x) -> x < 5) |> reversed |> tuple |> print

addpattern¶

Tato funkce přijímá argument, jenž je pattern-matching funkcí a vrací dekorátor, který přidává předlohy z existující funkce do nové dekorované funkce, v níž je existující předloha ověřována jako první. Její skladba je zhruba ekvivalentní k:

def addpattern(base_func):
    """Decorator to add a new case to a pattern-matching function, where the new case is checked last."""
    def pattern_adder(func):
        def add_pattern_func(*args, **kwargs):
            try:
                return base_func(*args, **kwargs)
            except MatchError:
                return func(*args, **kwargs)
        return add_pattern_func
    return pattern_adder

Mějte na paměti, že funkce, převzatá dekorátorem addpattern, musí být 'pattern-matchingová' funkce. Obdrží-li addpattern 'non-pattern-matchingovou' funkci, nevyvolá původní funkce hlášení MatchError. Tudíž, při volání této funkce nebude addpattern vědět, že první shoda selhala a správné cesty nebude nikdy dosaženo.

Například, následující kód vyvolá TypeError:

def print_type():
    print("Received no arguments.")

@addpattern(print_type)
def print_type(x is int):
    print("Received an int.")

print_type()  # appears to work
print_type(1) # TypeError: print_type() takes 0 positional arguments but 1 was given

Toto může být napraveno použitím klíčového slova match, činíce tak z funkce print_type() funkci pattern-matchingovou. V důsledku toho se všechna hlášení TypeErrors přemění na MatchErrors. Tato hlášení mohou být potom ošetřena dle potřeby novými addpattern dekorovanými funkcemi.

match def print_type():
    print("Received no arguments.")

@addpattern(print_type)
def print_type(x is int):
    print("Received an int.")

print_type(1)  # Works as expected
print_type("This is a string.") # Raises MatchError

addpattern může být použit bez klíčového slova match, pokud je příjímaná funkce přiřazovací funkcí, jak ukázáno v následujícím příkladu:

def factorial(0) = 1

@addpattern(factorial)
def factorial(n) = n * factorial(n - 1)

def prepattern(base_func):
    """Decorator to add a new case to a pattern-matching function,
    where the new case is checked first."""
    def pattern_prepender(func):
        return addpattern(func)(base_func)
    return pattern_prepender

reduce¶

Coconut znovu uvádí funkci reduce z Python2, používaje verze functools.reduce.

product = reduce$(*)
range(1, 10) |> product |> print

import operator
import functools
product = functools.partial(functools.reduce, operator.mul)
print(product(range(1, 10)))

takewhile¶

Coconut poskytuje itertools.takewhile jako vestavěnou funkci pod názvem takewhile.

def takewhile(predicate, iterable):
    # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break

negatives = takewhile(numiter, (x) -> x<0)

import itertools
negatives = itertools.takewhile(numiter, lambda x: x<0)

dropwhile¶

Coconut poskytuje itertools.dropwhile jako vestavěnou funkci pod názvem dropwhile.

def dropwhile(predicate, iterable):
    # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
    iterable = iter(iterable)
    for x in iterable:
        if not predicate(x):
            yield x
            break
    for x in iterable:
        yield x

positives = dropwhile(numiter, (x) -> x<0)

import itertools
positives = itertools.dropwhile(numiter, lambda x: x<0)

memoize¶

Coconut poskytuje functools.lru_cache jako 'built-in' pod jménem memoize, s tou úpravou, že parametr maxsize je nastaven implicitně na None. Procedura memoize usnadňuje optimalizaci rekurzivních funkcí, neboť maxsize argumentu None je obvykle to, co se žádá.

Použití memoize vyžaduje functools.lru_cache, jež existuje ve standardní knihovně v Python 3 ale v Python 2 bude požadovat pip install backports.functools_lru_cache. Navíc, při přítomnosti backports.functools_lru_cache v Python2, bude Coconut 'patch' functools tak, že functools.lru_cache = backports.functools_lru_cache.lru_cache.

@memoize(maxsize=32)
def get_pep(num):
    'Retrieve text of a Python Enhancement Proposal'
    resource = 'http://www.python.org/dev/peps/pep-%04d/' % num
    try:
        with urllib.request.urlopen(resource) as s:
            return s.read()
    except urllib.error.HTTPError:
        return 'Not Found'

>>> for n in 8, 290, 308, 320, 8, 218, 320, 279, 289, 320, 9991:
...     pep = get_pep(n)
...     print(n, len(pep))

>>> get_pep.cache_info()
CacheInfo(hits=3, misses=8, maxsize=32, currsize=8)