In che modo CoffeeScript è influenzato da Haskell?

Coffeescript è un farmaco gateway per Haskell. Diamo un'occhiata all'algoritmo Quicksort, presentato nel quinto capitolo di Learn You A Haskell For Great Good :

quicksort [] = []
quicksort (x:xs) =
       let smallerOrEqual = [a | a <- xs, a <= x]
           larger = [a | a <- xs, a > x]
       in quicksort smallerOrEqual ++ [x] ++ quicksort larger

E l'equivalente in Coffeescript:

quicksort = (x) ->
    return [] if x.length == 0
    h = x.pop()
    smallerOrEqual = (a for a in x when a <= h)
    larger = (a for a in x when a > h)
    (quicksort smallerOrEqual).concat([h]).concat(quicksort larger)

L'unica differenza evidente tra questi due bit di codice è che il pattern doveva essere trasformato in una condizione di guardia.

Questi sono non pezzi di codice equivalenti. Il codice Haskell farà pigramente solo le list comprehensions, cioè quando necessario dalla riga in . Il riconoscimento dei pattern è un grosso problema in Haskell. Haskell ottimizzerà questo codice con ricorsione in coda, mentre Coffeescript costruirà solo un framestack grande quanto il numero di ricorsi necessari. E la versione Haskell si preoccupa del contenuto della lista e chiede che siano tutti dello stesso tipo, dal momento che Haskell è così strongmente digitato.

Ma si potrebbe essere ingannati, con la loro chiara somiglianza sintattica, a credere che fossero equivalenti. E in una certa misura, uno sviluppatore intelligente poteva usare quella somiglianza per scrivere Coffeescript che, se non fosse pigro o strongmente tipizzato, era nondimeno meglio disciplinato e più funzionale. Haskell è un linguaggio eccellente per l'apprendimento di tale disciplina e tali abilità sono direttamente traducibili nella sintassi di Coffeescript.

[EDIT] Partendo dall'eccellente aggiunta di Linus di seguito, possiamo persino simulare la pigrizia di Haskell:

quicksort = ([x, xs...]) ->
    return [] unless x?
    smallerOrEqual = -> (a for a in xs when a <= x)
    larger = -> (a for a in xs when a > x)
    (quicksort smallerOrEqual()).concat(x).concat(quicksort larger())

Ora le due espressioni si innescano solo quando i loro risultati sono necessari, non solo imperativamente. Dubito che in realtà vinci qualsiasi cosa, ma sembra che si stia avvicinando ad una certa purezza haskelliana.

Basandosi sulla risposta di Elf Sternberg, puoi effettivamente rendere quicksort anche un po 'più "Haskell-like" con la destrutturazione di Coffeescript:

quicksort = ([x, xs...]) ->
  return [] unless x?
  smallerOrEqual = (a for a in xs when a <= x)
  larger = (a for a in xs when a > x)
  (quicksort smallerOrEqual).concat(x).concat(quicksort larger)

Non corrisponde a abbastanza , ma è un po 'più vicino. ; -)

Per me, CoffeeScript a volte sembra davvero simile a Erlang.

Ad esempio:

CoffeeScript:

f_qsort([]) -> []
f_qsort([Pivot, Rest...]) ->
  [
    f_qsort((X for X in Rest when X < Pivot))..., 
    Pivot, 
    f_qsort((Y for Y in Rest when Y >= Pivot))...
  ]

Erlang:

qsort([]) -> [];
qsort([Pivot|Rest]) ->
  qsort([ X || X <- Rest, X < Pivot]) 
  ++ [Pivot] ++ 
  qsort([ Y || Y <- Rest, Y >= Pivot]).

C'è una libreria che fornisce un modo per scrivere costruzioni simili a Erlang direttamente in CoffeeScript senza precompilazione, basta avvolgerlo in una funzione speciale. Puoi trovarlo qui: link .

Per me, la differenza principale è nelle chiamate alle funzioni. In CoffeScript:

fun(bar(a, b, c))

o

fun bar a, b, c

In Haskell:

fun $ bar a b c

o

fun . bar $ a b c

Perché oh perché quelle virgole tra argomenti.

Anche la differenza tra quicksort (x:xs) = e quicksort = ([x, xs...]) -> è ovvia e confusa, perché -> significa qualcos'altro in Haskell.