Quel est votre code fonctionnel intelligemment écrit préféré ?

Question

Quels sont vos extraits courts et époustouflants préférés dans les langages fonctionnels ?

Mes deux préférés sont (Haskell) :

powerset = filterM (const [True, False]) 

foldl f v xs = foldr (\x g a -> g (f a x)) id xs v -- from Hutton's tutorial

(J'ai étiqueté la question en tant que Haskell, mais les exemples dans tous les langages - y compris les non-FP - sont les bienvenus tant qu'ils sont dans l'esprit fonctionnel).

Answer 1

Mon moment "aha !" avec JavaScript s'est produit lorsque j'ai lu ceci mémorisation blog post. Le code fonctionnel pertinent, tiré de cet article, était le suivant :

Bezier.prototype.getLength = function() {
  var length = ... // expensive computation
  this.getLength = function(){return length};
  return length;
}

Fondamentalement, la fonction s'écrase elle-même avec la réponse après le premier calcul, ce qui rend tous les appels ultérieurs mémorisés.

C'est à ce moment-là que j'ai réalisé à quel point toutes mes idées préconçues sur la JS étaient fondées sur l'ignorance. Et c'est à ce moment-là que j'ai réalisé la véritable puissance de ses aspects fonctionnels.

Answer 2

bwp xs = map snd $ sort $ zip (rots xs) (rrot xs)
rots xs = take (length xs) (iterate lrot xs)
lrot xs = tail xs ++ [head xs]
rrot xs = last xs : init xs

Les (en avant) Transformation de Burrows-Wheeler d'une perle fonctionnelle papel . La BWT est utilisée comme deuxième étape dans la bzip2 la compression (après le codage de la longueur d'exécution), en regroupant les caractéristiques similaires pour rendre la plupart des entrées plus compressibles par les étapes suivantes.

L'article présente également quelques implémentations pour l'inverse, également élégantes mais pas aussi courtes.

Answer 3

Le moment où j'ai eu l'esprit le plus fort s'est produit en regardant la Cours vidéo SICP.
Les données sont constituées de air raréfié . Les fonctions en tant que conteneurs de données.

Plus précisément, stockez une paire de données même si le langage ne dispose pas d'un conteneur de données intégré.
C'était mon baptême de la programmation fonctionnelle.

#lang scheme

;; Version 1    
(define (pair x y)
  (lambda (p)
    (cond ((> p 0) x)
          (else y))))

(define (pair-x z)
  (z 1))

(define (pair-y z)
  (z 0))

;; Version 2, Alonzo Church Pairs - Lambda Calculus
;; SICP exercise
(define (church-pair x y)
  (lambda (m) (m x y)))

(define (church-pair-x z)
  (z (lambda (x y) x)))

(define (church-pair-y z)
  (z (lambda (x y) y)))

Exemple :

> (define p (pair 7 8))
> (pair-x p)
7
> (pair-y p)
8
>

Answer 4

Définitivement celui-ci (de wikipedia ) pour un interpréteur RPN court.

calc = foldl f [] . words
  where 
    f (x:y:zs) "+" = (y + x):zs
    f (x:y:zs) "-" = (y - x):zs
    f (x:y:zs) "*" = (y * x):zs
    f (x:y:zs) "/" = (y / x):zs
    f xs y = read y : xs

Et pour apporter un exemple un peu plus compliqué ;-) : Raytracer Linq

Answer 5

J'ai eu ça de Sean Seefried. Ici, nous utilisons le noeud coulant pour remplacer toutes les feuilles d'un arbre par la valeur minimale de la feuille en un seul passage.

data Tree
  = Fork Tree Tree
  | Leaf Int

aux i (Leaf i') = (i', Leaf i)
aux i (Fork t1 t2) =
  let (m1, t1') = aux i t1
      (m2, t2') = aux i t2
  in  (min m1 m2, Fork t1' t2')

replaceMin t =
  let (m, t') = aux m t in t'

Ainsi :

replaceMin (Fork (Leaf 4) (Leaf 7)) = Fork (Leaf 4) (Leaf 4)