Coconut¶

Instalace¶

Protože je Coconut hostován v Python Package Index, lze jej snadno instalovat s použitím pip. Jednoduše nainstalujte Python, otevřte příkazový řádek (cmd) a zadejte

pip install coconut

což nainstaluje Coconut a jeho požadované závislosti. Coconut sám má několik závislostí (dependencies), které lze instalovat zápisem

pip install coconut[all]

což umožní používání flagů --jobs, --watch a --jupyter. Pro instalaci pouze vybraného flagu, napište místo all název příslušného flagu.

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

pip install coconut-develop

což nainstaluje nejposlednější chodící development build (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] [source] [dest] [-t version] [-s] [-l] [-k] [-p] [-a] [-w] [-d] [-r] [-n] [-m] [-i] [-q] [-f] [-c code] [-j processes] [--jupyter ...] [--tutorial] [--documentation] [--style name] [--recursion-limit limit] [--verbose]

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, --target            specify target Python version (defaults to universal)
-s, --strict            enforce code cleanliness standards
-l, --line-numbers      add line number comments for ease of debugging
-k, --keep-lines        include source code in comments for ease of debugging
-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)
-w, --watch           watch a directory and recompile on changes (requires watchdog)
-d, --display           print compiled Python
-r, --run               run compiled Python (often used with --nowrite)
-n, --nowrite           disable writing compiled Python
-m, --minify            compress compiled Python
-i, --interact          force the interpreter to start (otherwise starts if no other command is given)
-q, --quiet             suppress all informational output (combine with --display to write runnable code to stdout)
-f, --force             force overwriting of compiled Python (otherwise only overwrites when source code or compilation parameters change)
-c, --code code         run a line of Coconut passed in as a string (can also be passed into stdin)
-j, --jobs processes    number of additional processes to use (defaults to 0) (pass 'sys' to use machine default)
--jupyter, --ipython    run Jupyter/IPython with Coconut as the kernel (remaining args passed to Jupyter)
--tutorial              open the Coconut tutorial in the default web browser
--documentation         open the Coconut documentation in the default web browser
--style name            pygments syntax highlighting style (or 'none' to disable)
--recursion-limit       set maximum recursion depth in compiler (defaults to 2000)
--verbose               print verbose debug output

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 a PyPy 2.7, 3.2.

V rámci snahy o vzájemnou kompabilitu (cross-compatibility), přidává Coconut nové Python 3 built-ins přepisuje Python 2 built-ins na Python 3 verze tam, kde je to možné. Navíc Coconut přepisuje některé Python 3 built-ins z optimalizačních důvodů. Je-li požadován přístup k verzím Pythonu, lze staré built-ins vydolovat s použitím předložky py_. Dostupné Python built-ins available jsou:

• py_chr
• py_filter
• py_hex
• py_input
• py_raw_input
• py_int
• py_oct
• py_open
• py_print
• py_range
• py_xrange
• py_str
• py_map
• py_zip

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),
• function type annotation,
• 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 (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 níž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, 26 (will work on any Python >= 2.6 but < 3),
• 27 (will work on any Python >= 2.7 but < 3),
• 3, 32 (will work on any Python >= 3.2),
• 33, 34 (will work on any Python >= 3.3),
• 35 (will work on any Python >= 3.5),
• 36 (will work on any Python >= 3.6),
• sys (chooses the specific target corresponding to the current version).

Poznámka: Čárky 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),
• missing new line at end of file (without --strict will show a Warning),
• use of from __future__ imports (without --strict will show a Warning)
• trailing whitespace at end of lines,
• semicolons at end of lines,
• use of the Python-style lambda statement,
• use of u to denote Unicode strings, and
• use of backslash continuations (use parenthetical continuation instead).

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.

Podpora pro IPython Jupyter¶

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

Lambda¶

Coconut poskytuje jednoduchý, čistý operátor -> jako alternativu k příkazu lambda v Pythonu. Skladba s operátorem -> je (arguments) -> expression. 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.

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 i když je vyžadován 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¶

K označení částečné aplikace používá Coconut znak $ mezi názvem funkce a závorkou před argumenty. It has the same precedence as subscription.

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 = map(pow$(2), range(5))
expnums |> list |> print

import functools
expnums = map(functools.partial(pow, 2), range(5))
print(list(expnums))

Vedení pipeline¶

Coconut používá vodící (pipe) operátory 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

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

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

Skladba¶

Coconut používá operátor .. pro skládání funkcí. It has a precedence in-between subscription and exponentiation. The in-place operator is ..=.

fog = f..g

# unlike this simple lambda, .. produces a pickleable object
fog = lambda *args, **kwargs: f(g(*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í 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. It has the same precedence as subscription.

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).

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

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*)                => "<*|"
⋅ (\u22c5)                  => "*"
↑ (\u2191)                  => "**"
÷ (\xf7)                    => "/"
÷/ (\xf7/)                  => "//"
∘ (\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)                  => "..."
× (\xd7)                    => "@" (only matrix multiplication)

data¶

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.

Bloky typu data vytvářejí v Coconut neměnitelné třídy pomocí parametru __slots__ a odvozené z collections.namedtuple. Skladba deklarace datového bloku vypadá takto:

data <name>(<args>):
    <body>

<name> je název nového datového typu, <args> jsou argumenty jeho konstruktoru stejně jako názvy jeho atributů a <body> obsahuje metody datového typu.

Subtřídy datových typů lze snadno vytvořit děděním do normální třídy Pythonu. Aby se stala nová subtřída neměnitelná, je nutné do ní vložit řádek

__slots__ = ()

před definicemi metod nebo atributů.

data vector(x, y):
    def __abs__(self):
        return (self.x**2 + self.y**2)**.5

v = vector(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

data Empty(): pass
data Leaf(n): pass
data Node(l, r): pass
Tree = (Empty, Leaf, Node)

def size(Tree()) = 0

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

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

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

import collections
class vector(collections.namedtuple("vector", "x, y")):
    __slots__ = ()
    def __abs__(self):
        return (self.x**2 + self.y**2)**.5

v = vector(3, 4)
print(v)
print(abs(v))
v.x = 2

import collections
class Empty(collections.namedtuple("Empty", "")):
    __slots__ = ()
class Leaf(collections.namedtuple("Leaf", "n")):
    __slots__ = ()
class Node(collections.namedtuple("Node", "l, r")):
    __slots__ = ()

def size(tree):
    if isinstance(tree, Empty):
        return 0
    elif isinstance(tree, Leaf):
        return 1
    elif isinstance(tree, Node):
        return size(tree[0]) + size(tree[1])
    else:
        raise MatchError()

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

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
    | "(" 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
      (")" | "]")                       # must both be parens or brackets
    | (                             # 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
    | pattern "is" exprs            # type-checking
    | pattern "and" pattern         # match all
    | pattern "or" pattern          # match any
    )

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(): pass
data Leaf(n): pass
data Node(l, r): pass
Tree = (Empty, Leaf, Node)

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                                  # 0
Leaf(5) |> depth |> print                                  # 1
Node(Leaf(2), Node(Empty(), Leaf(3))) |> depth |> print    # 3

def duplicate_first(value):
    match [x] + xs as l in value:
        return [x] + l
    else:
        raise TypeError()

[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

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)

Vyhrazené proměnné¶

Není povoleno aby název proměnné začínal _coconut, protože tyto proměnné jsou vyhrazeny pro kompilátor.

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 -> _, je 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ů, 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)

Literály množiny¶

Coconut umožňuje předsadit písmeno s nebo f před deklaraci setu (množiny). 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()

Literály imaginárního čísla¶

Jako doplněk k zápisu imaginárního čísla v Pythonu pomocí literálů <num>j nebo <num>J přidává Coconut ještě literály <num>i nebo <num>I pro zlepšení čitelnosti 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))

Podtržítkové separátory¶

Pro snadnější čitelnost umožňuje Coconut použití podtržítka pro optické rozdělení velkého čísla. Kompilátor tato podtržítka ignoruje.

10_000_000.0

10000000.0

Optimalizace koncového volání¶

Coconut provede automatickou optimalizaci koncovým voláním 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).

Poznámka: Optimalizace koncovým voláním 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 nebo prepattern.

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.

def factorial(n, acc=1):
    case n:
        match 0:
            return acc
        match _ is int if n > 0:
            return factorial(n-1, acc*n)
    else:
        raise TypeError("the argument to factorial must be an integer >= 0")

Operátorové funkce¶

Coconut používá jednoduchou výrazovou zkratku: uzavření do závorek činí z operátoru funkci. Podobně jako u iterátorových komprehencí, je-li operátorová funkce jediný argument funkce, mohou závorky volání funkce sloužit jako závorky operátorové funkce.

(|>)        => # pipe forward
(|*>)       => # multi-arg pipe forward
(<|)        => # pipe backward
(<*|)       => # multi-arg pipe backward
(..)        => # function composition
(.)         => (getattr)
(::)        => (itertools.chain) # will not evaluate its arguments lazily
($)         => (functools.partial)
(+)         => (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))))

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))

Infixové funkce¶

Coconut umožňuje infixové použití funkce, kde je název funkce umístěn mezi operandy a je obklopen zpětnými apostrofy. Volání se zpětným apostrofem (backtick calling) má prioritu mezi ‘chaining and piping’.

Skladba definice infixové funkce je

def <arg> `<name>` <arg>:  # asi má být `=` místo `:`
    <body>

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

Poznámka: 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))

Porovnávací funkce¶

Coconut podporuje porovnávání s předlohou (pattern-matching)/rozložené přiřazení (destructuring assignment) uvnitř definice funkce. Složení této skladby je

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

Kde <name> je název funkce, <cond> je nepovinná dodatečná kontrola, <body> je tělo funkce 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í definice porovnávací funkce od normální definice funkce, která má vždy přednost. Definice porovnávací (p-m) fukce je ekvivalentní příkazu match, který vypadá jako:

def <name>(*args):
    match (<pattern>, <pattern>, ...) in args:
        <body>
    else:
        err = MatchError(<error message>)
        err.pattern = "def <name>(<pattern>, <pattern>, ...):"
        err.value = args
        raise err

Selže-li průběh porovnávací funkce, vyvolá MatchError, stejně jako rozložené přiřazení.

Poznámka: 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

Rozložené přiřazení¶

Coconut podporuje výrazně zlepšené rozložené přiřazení (destructuring assignment), podobné rozkládání entice/seznamu v Pythonu. Skladba rozložené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í rozložené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

Příkazy else¶

Coconut podporuje složené příkazy try, if a match na konci příkazu else jako u každého jiného jednoduchého příkazu. To je nejvíce užitečné pro společné používání příkazů match a if a také umožňuje vytváření složených příkazů try.

try:
    unsafe_1()
except MyError:
    handle_1()
else: try:
    unsafe_2()
except MyError:
    handle_2()

try:
    unsafe_1()
except MyError:
    handle_1()
else:
    try:
        unsafe_2()
    except MyError:
        handle_2()

Příkazy except¶

Má-li být v Pythonu3 podchyceno více výjimek najednou, musejí být vloženy do závorek aby se v Pythonu2 zabránilo použití čárky místo as. Coconut umožňuje použití čárek ve výjimkových příkazech pro odchycení vícerých výjímek bez závorek.

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 zjednodušený zápis class name(base) a data name(args) místo class name(base): pass a data name(args): pass.

data Empty
data Leaf(item)
data Node(left, right)

import collections

class Empty(collections.namedtuple("Empty", "")):
    __slots__ = ()
class Leaf(collections.namedtuple("Leaf", "n")):
    __slots__ = ()
class Node(collections.namedtuple("Node", "l, r")):
    __slots__ = ()

Pokračování v závorkách¶

Coconut umožňuje u příkazů del, global, nonlocal a with rozložení zápisu na více řádků s použitím závorek místo zpětných lomítek \ jako u Pythonu.

global (really_long_global_variable_name_the_first_one,
        really_long_global_variable_name_the_second_one)

global really_long_global_variable_name_the_first_one, \
        really_long_global_variable_name_the_second_one

Zjednodušené určení global a nonlocal¶

Coconut umožňuje deklaraci global či nonlocal v jednom řádku bez opakování názvu proměnné.

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í \\.

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

cdef f(x):
    return g(x)

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

def factorial(0) = 1

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

prepattern¶

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í. Je zhruba ekvivalentní k:

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

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

@prepattern(factorial)
def factorial(0) = 1

reduce¶

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

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

import operator
import functools
prod = functools.partial(functools.reduce, operator.mul)
print(prod(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)

tee¶

Coconut poskytuje optimalizovanou verzi itertools.tee jako vestavěnou funkci pod názvem tee.

def tee(iterable, n=2):
    it = iter(iterable)
    deques = [collections.deque() for i in range(n)]
    def gen(mydeque):
        while True:
            if not mydeque:             # when the local deque is empty
                newval = next(it)       # fetch a new value and
                for d in deques:        # load it to all the deques
                    d.append(newval)
            yield mydeque.popleft()
    return tuple(gen(d) for d in deques)

original, temp = tee(original)
sliced = temp$[5:]

import itertools
original, temp = itertools.tee(original)
sliced = itertools.islice(temp, 5, None)

consume¶

Coconut poskytuje funkci consume pro účinné vyčerpání iterátoru a pro provedení líného výpočtu. Funkce consume přijímá volitelný argument, keep_last, jehož implicitní hodnota je 0 a určuje kolik položek od konce vrátit jako iterábl (None zachová všechny prvky). Ekvivalentní k:

def consume(iterable, keep_last=0):
    """Fully exhaust iterable and return the last keep_last elements."""
    return collections.deque(iterable, maxlen=keep_last) # fastest way to exhaust an iterator

range(10) |> map$((x) -> x**2) |> map$(print) |> consume

collections.deque(map(print, map(lambda x: x**2, range(10))), maxlen=0)

count¶

Coconut poskytuje modifikovanou verzi itertools.count, která podporuje in, normální členění (slicing), optimalizoané členění iterátoru, sekvenční metody count a index, atributy repr, _start a _step jako vestavěnou funkci jménem count.

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) -> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

count()$[10**100] |> print

map a zip¶

Objekty map a zip v Coconut jsou vylepšené ekvivalenty Pythonu, které podporují optimalizované normální (a iterátorové) členění, postupy reversed, len, repr a mají přidané atributy, jež mohou použít subtřídy k přístupu k původním argumentům objektu (map podporuje _func a atributy _iters a zip podporuje atributy _iters).

map((+), range(5), range(6)) |> len |> print

datamaker¶

Coconut poskytuje funkci datamaker pro přímý přístup k bázovému konstruktoru datových typů, vytvořenému příkazem data. Toto je zejména užitečné při psaní alternativních konstruktorů pro datové typy přepsáním metody __new__. Ekvivalentní k:

def datamaker(data_type):
    """Returns base data constructor of data_type."""
    return super(data_type, data_type).__new__$(data_type)

data trilen(h):
    def __new__(cls, a, b):
        return (a**2 + b**2)**0.5 |> datamaker(cls)

import collections
class trilen(collections.namedtuple("trilen", "h")):
    __slots__ = ()
    def __new__(cls, a, b):
        return super(cls, cls).__new__(cls, (a**2 + b**2)**0.5)

recursive iterator¶

Coconut poskytuje dekorátor recursive_iterator, který poskytuje výraznou optimalizaci pro každou bezstavovou (stateless) rekurzivní funkci, která vrací iterátor. Pro použití recursive_iterator u funkce musí být splněna následující kritéria:

1. vaše funkce buď vždy vrací iterátor nebo generuje iterátor pomocí yield,
2. při opakovaném volání pro tytéž argumenty produkuje vaše funkce tentýž iterátor (vaše funkce je bezestavová),
3. vaše funkce volá samu sebe pro tytéž argumenty,
4. všechny argumenty, zadávané funkci jsou serializovatelné (pickleable).

Setkáte-li se s RuntimeError následkem maximální hloubky rekurze, je vhodné přepsat funkci tak, aby vyhověla buď výše uvedenému požadavku na recursive_iteratornebo odpovídajícím kritériím pro optimalizaci koncového volání, jež obojí by mělo takovým chybám zabránit.

Nadto, recursive_iterator také umožňuje řešení of nasty segmentation fault in Python’s iterator logic that has never been fixed. Konkrétně, místo zápisu

seq = get_elem() :: seq

které havaruje v důsledku výše uvedeného problému, pište

@recursive_iterator
def seq() = get_elem() :: seq()

které poběží uspokojivě.

@recursive_iterator
def fib() = (1, 2) :: map((+), fib(), fib()$[1:])

parallel map¶

Coconut poskytuje paralelní verzi map pod názvem parallel_map. parallel_map využívá více procesů a je proto mnohem rychlejší než map pro úlohy, svázané s CPU. Použití parallel_map vyžaduje concurrent.futures, jež existují ve standardní knihovně Python 3, avšak v Python 2 bude zapotřebí provést pip install futures.

Protože parallel_map používá ke svému provedení více procesů, je nezbytné aby všechny její argumenty byly serializovatelné. Serializovatelné (pickleable) jsou pouze objekty definované na úrovni modulu, uvnitř funkce nebo uvnitř interpreta. Navíc, ve Windows je nezbytné aby se všechna volání parallel_map vyskytla uvnitř dozoru if __name__ == "__main__".

parallel_map(pow$(2), range(100)) |> list |> print

import functools
import concurrent.futures
with concurrent.futures.ProcessPoolExecutor() as executor:
    print(list(executor.map(functools.partial(pow, 2), range(100))))

concurrent map¶

Coconut poskytuje concurrentní verzi map pod názvem concurrent_map. concurrent_map využívá více vláken a je proto mnohem rychlejší než map u úloh související s IO. Použití concurrent_map vyžaduje concurrent.futures, jež existuje ve standardní knihovně Python 3, avšak v Python 2 bude zapotřebí provést pip install futures.

concurrent_map(get_data_for_user, get_all_users()) |> list |> print

import functools
import concurrent.futures
with concurrent.futures.ThreadPoolExecutor() as executor:
    print(list(executor.map(get_data_for_user, get_all_users())))

MatchError¶

Objekt MatchError je vyvolán, když selže destructuring assignment, načež je MatchError poskytnut jako vestavěná procedura pro odchycení takovýchto chyb. Objekty MatchError podporují dva atributy, pattern, což je řetězec, popisující selhávající předlohu a value, což je objekt, který selhal při porovnávání s předlohou.

Zvýraznění skladby¶

Současné možnosti pro zvýraznění skladby v Coconut jsou tyto:

1. use SublimeText (instructions below),
2. use an editor that supports Pygments (instructions below),
3. use coconut.vim, a third-party Vim highlighter,
4. use coconut-mode, a third-party Emacs highlighter, or
5. just treat Coconut as Python.

Pokyny pro nastavení skladby zvýrazňování pro SublimeText a Pygments jsou uvedeny níže. Pokud některý z výše uvedených zvýrazňovačů nechodí, potom by mělo stačit nastavit editor tak, aby interpretoval všechny soubory .coco (také .coc a .coconut, byť .coco je preferovaná přípona) jako kód Pythonu, neboť se tak dostatečně zvýrazní většina vašeho kódu.

highlight_language = "coconut"

coconut.coconut¶

Toto je občas užitečné pro přístup k vestavěným objektům Coconutu z čistého Pythonu. Za tím účelem Coconut poskytuje coconut.__coconut__, jenž se chová přesně jako hlavičkový soubor __coconut__.py, připojený když je Coconut kompilován v režimu ‘package’.

Všechny nativní objekty Coconutu jsou přístupné z coconut.__coconut__. Doporučený způsob jejich importu je použití from coconut.__coconut__ import.

from coconut.__coconut__ import parallel_map

coconut.convenience¶

Někdy je užitečné mít možnost použít kompilátor Coconutu z kódu místo z příkazového řádku. Doporučuje se použít from coconut.convenience import a importovat potřebnou užitečnou (convenience) funkci. Specifikace různých ‘convenience’ funkcí jsou uvedeny dále.

Instalace¶

Ve své podstatě je Coconut kompilátor, který převádí kód v Coconut na kód v Pythonu. To znamená, že tam, kde lze použít skript Pythonu, lze také použít skript Coconut. Pro přístup k tomuto kompilátoru poskytuje Coconute utilitu CLI (command line interface), která dovede:

• kompilovat jednotlivé soubory nebo celé projekty,
• překládat za pochodu kód Coconut,
• včlenit se (hook into) do existujících aplikací Pythonu, jako IPython či Jupiter.

Instalace Coconut je velmi jednoduchá:

1. instalujte Python,
2. otevřte konzolu s příkazovým řádkem
3. a zadejte:

pip install coconut

Pro kontrolu, že instalace proběhla správně, zkuste na příkazový řádek zadat

coconut -h

což by mělo zobrazit nápovědu pro Coconut.

Použití překladače¶

Nyní, když máte Coconut nainstalovaný, zkusíme s ním něco provádět. Překladač (interpret) spustíte z příkazového řádku zápisem

coconut

načež byste měl číst něco jako

Coconut Interpreter:
(type "exit()" or press Ctrl-D to end)
>>>

což je oznámení Coconut, že je připraven pro zadávání a vyhodnocování kódu. Tož pusťme se do toho!

Pro případ, že jste to dříve přehlédli - veškerý platný Python 3 je platný Coconut. To neznamená, že kompilovaný Coconut poběží pouze na Python 3, protože poběží stejně i na Python 2, ale že pouze kód Python 3 je spolehlivě kompilován do kódu Coconut.

Z toho vyplývá, že jste-li důvěrně seznámen s Pythonem, jste již z větší části seznámen se skladbou Coconut a jeho celou standardní knihovnou. Zkusme pro ukázku zadat nějaký jednoduchý kód Pythonu do překladače Coconut:

>>> "hello, world!"
hello, world!
>>> 1 + 1
2

Použití kompilátoru¶

Ovšemže, být schopen za běhu interpretovat kód Coconut je velká věc ale bez schopnosti psát a kompilovat programy by naše programování nebylo příliš užitečné. Pojďme si proto napsat první program v Coconut: “Hello, world!”.

Nejprve vytvoříte soubor, do něhož náš kód vložíte. Doporučená extenze pro zdrojové soubory Coconut je .coco, vytvořte tedy soubor s názvem hello_world.coco. Poté, co to uděláte, měli byste nastavit svůj textový editor na správné zvýrazňování zdrojového kódu. Příslušné instrukce naleznete v odstavci Zvýraznění skladby. Dokumentace

Nyní vložíme kód do souboru hello_world.coco. Na rozdíl od Pythonu, kde záhlaví a různé importy jsou obvyklé a velmi často velmi nezbytné,

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from __future__ import print_function, absolute_import, unicode_literals, division

provede kompilátor Coconut potřebné importy automaticky, takže jediné o co se musíte starat, je vlastní kód.

V čistém Pythonu 3 má příkaz k tisku formát:

print("hello, world!")

a stejně tak i v Coconut, kde navíc je možné použít potrubní (pipeline) usměrnění v zápisu:

"hello, world!" |> print

z něhož je zřetelně vidět, jak operátor |> způsobí předání řetězce coby argument následné funkci, jíž je v tomto případě příkaz k tisku. Nyní náž jednoduchý program “hello_world” uložíme a zkusíme jej spustit.

Kompilování souborů a projektů utilitou Coconut je vemi jednoduché. Zapíšeme pouze

coconut hello_world.coco

což vytvoří výstup

Coconut: Compiling       hello_world.coco ...
Coconut: Compiled to       hello_world.py .

Soubor hello_world.py uložte do stejného adresáře jako hello_world.coco a měl byste být schopen spustit soubor příkazem

python hello_world.py

což by mělo vyprodukovat výstup hello, world!.

Kompilování jednotlivých souborů ovšem není jediný způsob použití kompilátoru Coconut. Můžeme také kompilovat všechny soubory v daném adresáři najednou a to pouhým uvedením názvu adresáře.

coconut `název_adresáře`

Kompilátor si sám vyhledá všechny kompilovatelné soubory a vytvoří pomocný soubor __coconut__.py, do něhož uloží potřebné informace z jednotlivých souborů.

Kompilátor Coconut podporuje velké množství různých kompilačních možností - viz nápověda coconut -h. Nejužitečnější z nich je opce --linenumbers (nebo zkráceně -l), která přidává čísla řádků ze zdrojového kódu do kompilovaného kódu, umožňujíce tak při ladění vidět číslo zdrojového kódu, odpovídající chybujícímu řádku kompilovaného kódu.

Použití IPython / Jupyter¶

Coconut usiluje o rozsáhlou podporu zavedených nástrojů pro vědecké výpočty v Pythonu.

To zahrnuje podporu aplikace IPython (jádro Pythonu pro framework Jupyter) místo klasické konzoly Pythonu. Coconut je použit jak jako jádro pro notebooky a konzoly Jupytera, tak jako rozšíření uvnitř jádra IPythonu.

Pro spuštění notebooku Jupytera s Coconut jako jádrem použijete příkaz

coconut --jupyter notebook

a pro spuštění konzoly Jupytera použijete příkaz

coconut --jupyter console

nebo lze ekvivalentně v obou příkazech zaměnit --ipython za --jupyter.

Pro použití Coconut jako extenzi uvnitř jádra IPythonu zapište

%load_ext coconut

do svého notebooku či konzoly IPythonu a poté spusťte kód Coconut zápisem

%coconut <code>

nebo

%%coconut <command-line-args>
<code>

Případové studie¶

Protože byl Coconut vytvořen se záměrem aby byl užitečný, bude nejlépe jej předvést v akci při řešení konkrétních problémů, které jsou v tomto tutoriálu označeny jako případové studie.

Tyto případové studie ovšem nepřinášejí úplný přehled všech vlastností Coconut. Ten lze nalézt v obsáhlé dokumentaci.

Imperativní metoda¶

Imperativní přístup bychom při psaní factoriálu použili v jazyce typu C. Imperativní přístupy zahrnují mnohé změny stavu, kdy jsou pravidelně měněny proměnné při procházení smyčkou. Imperativní přístup v Coconut vypadá nějak takto:

def factorial(n):
    """Compute n! where n is an integer >= 0."""
    if n `isinstance` int and n >= 0:
        acc = 1
        for x in range(1, n+1):
            acc *= x
        return acc
    else:
        raise TypeError("the argument to factorial must be an integer >= 0")

# Test cases:
-1 |> factorial |> print # TypeError
0.5 |> factorial |> print # TypeError
0 |> factorial |> print # 1
3 |> factorial |> print # 6

Předtím, než se budeme zabývat průběhem výpočtu, ověřme si nejprve testovací případy. Kdybychom psali skutečný program, uložili bychom jej do souboru, jenž bychom kompilovali ale protože si jenom zkoušíme věci, vystačíme si s překopírováním kódu do překladače (byť úprava skriptu má také své výhody). Měli bychom dostat 1, 6 a dvakrát TypeError.

Nyní, když jsme si ověřili, že nám kód chodí správně, pohleďmě o co v něm kráčí. Protože je imperativní přístup zcela nefunkcionální, Coconut nám v tomto případě příliš nepomůže. Avšak i zde činí použití infixové notace (vložení funkce isinstance mezi argumenty: n a int) kód čistší a čitelnější.

Rekurzivní metoda¶

Rekurzivní metoda je první ze zcela funkcionálních přístupů a to v tom, že nezahrnuje změnu stavu ve smyčce jako u imperativního přístupu. Rekurzivní přístup nahrazuje potřebu explicitně měněné proměnné její implicitní změnou v rekurzivním volání funkce:

def factorial(n):
    """Compute n! where n is an integer >= 0."""
    case n:
        match 0:
            return 1
        match _ is int if n > 0:
            return n * factorial(n-1)
    else:
        raise TypeError("the argument to factorial must be an integer >= 0")

# Test cases:
-1 |> factorial |> print # TypeError
0.5 |> factorial |> print # TypeError
0 |> factorial |> print # 1
3 |> factorial |> print # 6

Překopírujte si kód a testy do překladače.

Proberme si specifika syntaxe v tomto příkladu. První věcí je case n. Tento příkaz spouští blok case, v němž se mohou vyskytnout pouze příkazy match. Každý příkaz match se pokouší porovnat svou předlohu s hodnotou bloku case. U první úspěšné shody jsou realizována všechna připojení proměnných. Navíc, jak je tomu v tomto případě, mohou mít příkazy match také kontrolky (guards) if, které deklarují podmínku pro další provedení kódu. Posléze, za blokem case je příkaz else který se provede jen v případě absence jakékoliv shody.

Konkretně v tomto příkladě ověřuje první příkaz match, zda je n shodné s 0. Pakliže ano, provede se return 1. Následně druhý příkaz match ověřuje, zda se n shoduje s _ is int, což je adekvátní idiomu n je instancí int a zda je n > 0. Jsou-li všechny kontroly pozitivní, provede se příkaz return n * factorial(n-1). Nedojde-li k provedení žádného příkazu, přichází ke slovu příkaz else, který spustí a provede raise TypeError("argument faktoriálu musí být celé číslo >= 0").

I když je tento příklad velmi prostý, je postup v něm použitý, zvaný pattern-matching (porovnání předlohy), jedním z nejmocnějších i nejsložitějších postupů v Coconut. Jako obecné vodítko poslouží asociativní spojení pojmu přiřazení s klíčovým slovem match.

Svým způsobem ještě složitější je inverzní postup k pattern matching, jímž je destructuring assignment (rozložené přiřazení), jež v našem případě pro funkci factorial má skladbu:

def factorial(n):
    """Compute n! where n is an integer >= 0."""
    try:
        0 = n # destructuring assignment
    except MatchError:
        try:
            _ is int = n # also destructuring assignment
        except MatchError:
            pass
        else: if n > 0: # in Coconut, if, match, and try are allowed after else
            return n * factorial(n-1)
    else:
        return 1
    raise TypeError("the argument to factorial must be an integer >= 0")

# Test cases:
-1 |> factorial |> print # TypeError
0.5 |> factorial |> print # TypeError
0 |> factorial |> print # 1
3 |> factorial |> print # 6

Ukázku si nejprve překopírujte do překladače! I když toto rozložené přiřazení bude také chodit, je mnohem více neohrabané než příkazy match. Tato alternativa nám ale ozřejmí, že příkazy match jsou ve skutečnosti nóbl rozložená přiřazení, jež jsou ve skutečnosti nóbl normální přiřazení. Při použití rozloženého místo normálního přiřazení, lze před rozložené přiřazení vložit pro zdůraznění klíčové slovo match.

Při používání příkazů pro pattern-matching a destructuring assignment v dalších uázkách bude užitečné, když si pomyslíme přiřazení pokaždé, když uvidíme klíčové slovo match.

Až dosud jsme se u rekurzivní metody zabývali pouze porovnáním předlohy (pattern matching) ale ve skutečnosti existuje další způsob, jímž můžeme vylepšit naši funkci factorial. Coconut provádí automatickou optimalizaci koncového volání, což znamená že kdykoli funkce vrací přímo volání jiné funkce, zadrží (optimize away) Coconut další volání. Naši funkci factorial tedy přepíšeme pro použití koncového volání:

def factorial(n, acc=1):
    """Compute n! where n is an integer >= 0."""
    case n:
        match 0:
            return acc
        match _ is int if n > 0:
            return factorial(n-1, acc*n)
    else:
        raise TypeError("the argument to factorial must be an integer >= 0")

# Test cases:
-1 |> factorial |> print # TypeError
0.5 |> factorial |> print # TypeError
0 |> factorial |> print # 1
3 |> factorial |> print # 6

Copy, paste! Tato nová funkce factorial je ekvivalentní originální verzi s tou výjimkou, že nikdy nevyvolá RuntimeError v důsledku dosažení maximální hloubky rekurze v Pythonu, protože Coconut odstaví (optimize away) koncové rekurzivní volání.

Iterativní metoda¶

Tato metoda je dalším funkcionálním přístupem k řešení problému. Iterativní přístupy obcházejí potřebu změny stavu a smyček použitím funkcí vyššího řádu, které jako argumenty přijímají jiné funkce jako map a reduce k vyčlenění základních prováděných operací. Iterativní přístup k factoriálu v Coconut je tento:

def factorial(n):
    """Compute n! where n is an integer >= 0."""
    case n:
        match 0:
            return 1
        match _ is int if n > 0:
            return range(1, n+1) |> reduce$(*)
    else:
        raise TypeError("the argument to factorial must be an integer >= 0")

# Test cases:
-1 |> factorial |> print # TypeError
0.5 |> factorial |> print # TypeError
0 |> factorial |> print # 1
3 |> factorial |> print # 6