Archivi Categorie: Coconut

Coconut – comincio

amsterdam

Dopo la ricognizione a volo d’uccello mi sembra che Coconut possa essere utile come complemento di Python; non lo sostituisce ma aggiunge qualcosa. È un linguaggio giovane, sviluppato da un giovane nerd volonteroso —Evan Hubinger— gli auguro che la sua avventura sia simile a quella di Guido, quello di Python 😀

Allora inizio, copiando qui.
Coconut is a variant of Python built for simple, elegant, Pythonic functional programming. Coconut syntax is a strict superset of Python 3 syntax. That means users familiar with Python will already be familiar with most of Coconut.

The Coconut compiler turns Coconut code into Python code. The primary method of accessing the Coconut compiler is through the Coconut command-line utility, which also features an interpreter for real-time compilation. In addition to the command-line utility, Coconut also supports the use of IPython/ Jupyter notebooks.

While most of Coconut gets its inspiration simply from trying to make functional programming work in Python, additional inspiration came from Haskell, CoffeeScript, F#, and patterns.py.

OK 😀 con la nuova versione di IPython ho superato i problemi che avevo riscontrato ma vedo con piacere che conviene usare la REPL di Coconut.
Poi torna il riferimento a Haskell che prima o poi… Ma c’è Octave che sta diventando urgente; e ci sono altre cose… Gli altri suggerimenti per il momento li ignoro.

Per installarlo (io già fatto, ovviamente) si usa python -m pip install coconut; anzi meglio python -m pip install coconut all in modo da installare le componenti opzionali.

Per l’uso c’è l’opzione -h o --help. Uh! creo l’alias coco:

c16

Quasi OK: 1) anche i grandi sbagliano, figurarsi io (me); e 2) il warning me lo aspettavo i giallo, ma va bene anche così.

Notare le opzioni --tutorial e --documentation che fanno esattamente quello che io faccio fare a scripts; Evan rockz! 😀

Estensioni per i nomi dei files
Coconut source files should, so the compiler can recognize them, use the extension .coco (preferred), .coc, or .coconut. When Coconut compiles a .coco (or .coc / .coconut) file, it will compile to another file with the same name, except with .py instead of .coco, which will hold the compiled code. If an extension other than .py is desired for the compiled files, such as .pyde for Python Processing, then that extension can be put before .coco in the source file name, and it will be used instead of .py for the compiled files. For example, name.coco will compile to name.py, whereas name.pyde.coco will compile to name.pyde.

Modi di compilazione
Uhmmm… si possono compilare tutti i files in una diretory e nelle sue sotto-directory (ricorsivamente per tutto l’albero) ma forse conviene –in condizioni normali– compilare i files singolarmente; la descrizione dettagliata è qui.

Versioni Python supportate
While Coconut syntax is based off of Python 3, Coconut code compiled in universal mode (the default --target), and the Coconut compiler, should run on any Python version >= 2.6 on the 2.x branch or >= 3.2 on the 3.x branch.

Questo corregge quanto detto da me precedentemente. Notare l’opzione --target; provata per hello-wordl.coco con 2.7 e 3.5 dove ha prodotto outputs decisamente diversi (non riporto, troppo lunghi):

c17

È inoltre possibile usare prefissi per definire condizioni particolari (versione 2.x), elencate nella documentazione citata. Uh! anche per 3.x.

Continua :mrgreen:

Coconut – 3 – continuo le prove

ldi

Continuo da qui e il tutorial mi promette di colmare le lacune 😀

In this last section, we’ll touch on three of the most important features of Coconut that we managed to miss in our case studies: lazy lists, function composition, and implicit partials.

Lazy lists
Lazy lists are lazily-evaluated iterator literals, similar in their laziness to Coconut’s :: operator, in that any expressions put inside a lazy list won’t be evaluated until that element of the lazy list is needed. The syntax for lazy lists is exactly the same as the syntax for normal lists, but with “banana brackets” ((| and |)) instead of normal brackets, like so:

c13

devo solo scoprire come si usa, sono niubbo 😳

Cmposizione di funzioni
In Coconut, this is accomplished through the .. operator, which takes two functions and composes them, creating a new function equivalent to (*args, **kwargs) -> f1(f2(*args, **kwargs)). This can be useful in combination with partial application for piecing together multiple higher-order functions, like so:zipsum = map$(sum)..zip.

Function composition also gets rid of the need for lots of parentheses when chaining function calls, like so:

c14

che rispetto al modo classico è più chiaro:

c15

Implicit partials
Coconut supports a number of different “incomplete” expressions that will evaluate to a function that takes in the part necessary to complete them, that is, an implicit partial application function. The different allowable expressions are: .name, obj., func$, seq[], iter$[].
Mysteryousassay 😳

Questo conclude il Coconut Tutorial; chissà se… anzi: prossimamente, forse 😳

:mrgreen:

Coconut – 2 – intermezzo per qualche riflessione

Wiz

Non ho ancora deciso se Coconut diventerà uno dei miei linguaggi; devo approfondire.
Ma sospendo un attimo –da qui— per qualche considerazione –banale lo so!– su come comportarmi.

c13

Nella REPL di Coconut si possono dare i comandi sia con la sua propria sintassi che con quella di Python. Può essere comodo 😀

c14

Con Python (versione 2.x che è comunque quella usata da Coconut) sono più limitato; notare p.es. la print senza importarla dal futuro. Per contro è molto più veloce.

c15-0

IPython (a proposito ho creato l’alias per risparmiare i diti):

c15-1

Mi accorgo che devo approfondire, chissà …

Finora ho trattato comandi semplici; con le funzioni ho

c16

notare che si devono inserire gli spazi richiesti da Python; anche la riga vuota per terminare la funzione è richiesta.

c17

Stessa cosa con IPython.

c18

Coconut fa le bizze con funzioni Python

c19

le vuole con la sua sintassi. Ed è più lento.

Basta, ho deciso che devo vedere bene IPyton; pausa 😀

:mrgreen:

Coconut – 1 – prime prove con un case study

sg4

Continuo l’esame di Coconut, iniziato qui, per vedere se può essere utile per estendere Python, premettendo che è tutto da un punto di vista strettamente personale. Oggi qualche case study, sempre dal tutorial.

Fattoriale

In the first case study we will be defining a factorial function, that is, a function that computes n! where n is an integer >= 0.
To start off with, we’re going to have to decide what sort of an implementation of factorial we want. There are many different ways to tackle this problem, but for the sake of concision we’ll split them into four major categories: imperative, recursive, iterative, and addpattern.

Metodo imperativo

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

c6

OOPS! non come volevo, provo dentro IPython:

c7

No, continua a non funzionare. Intanto ho dovuto cambiare il nome al file, il carattere – viene interpretato. Ma resta l’errore sulla metaclasse. Solo per verifica provo a togliere dal codice .coco e casi che danno errore e ricompilare:

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

c8

Sì ma così non ha senso; supponiamo che il parametro a factorial sia dato interattivamente c’è il crash. Insomma no 😦

Metodo ricorsivo
Continuo ad avere errori; salto al prossimo case study: quick_sort.

Case study 2: quick_sort

Sortare una sequenza

def quick_sort([]):
    return []

@addpattern(quick_sort)
def quick_sort([head] + tail):
    """Sort the input sequence using the quick sort algorithm."""
    return (quick_sort([x for x in tail if x < head])         + [head]         + quick_sort([x for x in tail if x >= head]))

# Test cases:
[] |> quick_sort |> print 
[3] |> quick_sort |> print 
[0,1,2,3,4] |> quick_sort |> print 
[4,3,2,1,0] |> quick_sort |> print 
[3,0,4,2,1] |> quick_sort |> print

c9

OK, provo a compilare…

c10

OK, dentro IPython ho ***errori*** devo approfondire come si usa.

Sortare un iteratore

def quick_sort(l):
    """Sort the input iterator, using the quick sort algorithm, and
       without using any data until necessary."""
    match [head] :: tail in l:
        tail, tail_ = tee(tail)
        yield from (quick_sort((x for x in tail if x < head))             :: (head,)             :: quick_sort((x for x in tail_ if x >= head))
            )

# Test cases:
[] |> quick_sort |> list |> print 
[3] |> quick_sort |> list |> print 
[0,1,2,3,4] |> quick_sort |> list |> print 
[4,3,2,1,0] |> quick_sort |> list |> print 
[3,0,4,2,1] |> quick_sort |> list |> print

c11

e compilando:

c12

Pausa 😉 perplesso 😳 devo vedere cli altri casi prima di giungere a una conclusione :mrgreen:

Coconut – 0 – e se…

banner

E se Coconut riesce a estendere Python come dice…
Da provare, installo

c0

e provo subito, seguendo le dritte di Coconut Tutorial:

c1


OK
, c’è; avanti 😀

Usare il compilatore

Of course, while being able to interpret Coconut code on-the-fly is a great thing, it wouldn’t be very useful without the ability to write and compile larger programs. To that end, it’s time to write our first Coconut program: “hello, world!” Coconut-style.

First, we’re going to need to create a file to put our code into. The recommended file extension for Coconut source files is .coco, so let’s create the new file hello_world.coco.

Prima sorpresa: non serve la shebang, non servono gli usuali soliti import e la sintassi è (come già visto nel test sopra) un po’ diversa, insomma ecco hello_world.coco:

"hello, world!" |> print

compilo:

c2

OK, produce hello_world.py decisamente più lungo di quel che mi aspettavo.
C’è la shebang, gli import, tante definizioni di funzioni e alla fine

# Compiled Coconut: ------------------------------------------------------------

(print)("hello, world!")

che si può lanciare:

c3

Usare IPython o Jupyter

uhmmm…
Non ho nessuno dei due installati; prima o poi Jupyter potrebbe tentarmi, per intanto inizio con IPython.

c4

e poi …

c5

OK, lento ma è un caso scemo; poi sono niubbassay 😳

nome

If you don’t get the reference, the image above is from Monty Python and the Holy Grail, in which the Knights of the Round Table bang Coconuts together to mimic the sound of riding a horse. The name was chosen to reference the fact that Python is named after Monty Python as well.

evan

Chi è stato?

Evan Hubinger is an undergraduate student studying mathematics and computer science at Harvey Mudd College. Fa anche altre cose, tante, rockz 😀

Pausa, ma devo continuare a indagare.

:mrgreen: