En Programmation Fonctionnelle, ce qui est un foncteur?

autres réponses ici sont complètes, mais je vais essayer une autre explication de L'utilisation de la FP functor . Prenez ceci comme analogie:

Un foncteur est un conteneur de type un qui, lorsqu'il est soumis à une fonction que des cartes à partir de un → b , les rendements d'un conteneur de type b .

contrairement à la abstrait-la fonction de pointeur utiliser en C++, ici le foncteur est pas la fonction; c'est plutôt quelque chose qui se comporte de manière uniforme lors de la objet à une fonction .

Il y a trois significations différentes, pas beaucoup!

• en Ocaml c'est un module paramétrisé. Voir manuel . Je pense que la meilleure façon de grok, c'est par exemple: (écrit rapidement, peut-être buggé)

  module type Order = sig
      type t
      val compare: t -> t -> bool
  end;;
  
  
  module Integers = struct
      type t = int
      let compare x y = x > y
  end;;
  
  module ReverseOrder = functor (X: Order) -> struct
      type t = X.t
      let compare x y = X.compare y x
  end;;
  
  (* We can order reversely *)
  module K = ReverseOrder (Integers);;
  Integers.compare 3 4;;   (* this is false *)
  K.compare 3 4;;          (* this is true *)
  
  module LexicographicOrder = functor (X: Order) -> 
    functor (Y: Order) -> struct
      type t = X.t * Y.t
      let compare (a,b) (c,d) = if X.compare a c then true
                           else if X.compare c a then false
                           else Y.compare b d
  end;;
  
  (* compare lexicographically *)
  module X = LexicographicOrder (Integers) (Integers);;
  X.compare (2,3) (4,5);;
  
  module LinearSearch = functor (X: Order) -> struct
      type t = X.t array
      let find x k = 0 (* some boring code *)
  end;;
  
  module BinarySearch = functor (X: Order) -> struct
      type t = X.t array
      let find x k = 0 (* some boring code *)
  end;;
  
  (* linear search over arrays of integers *)
  module LS = LinearSearch (Integers);;
  LS.find [|1;2;3] 2;;
  (* binary search over arrays of pairs of integers, 
     sorted lexicographically *)
  module BS = BinarySearch (LexicographicOrder (Integers) (Integers));;
  BS.find [|(2,3);(4,5)|] (2,3);;
  

vous pouvez maintenant ajouter rapidement beaucoup d'ordres possibles, des façons de former de nouveaux ordres, faire une recherche binaire ou linéaire facilement sur eux. Programmation générique FTW.

• dans les langages de programmation fonctionnelle comme Haskell, cela signifie certains types de constructeurs (types paramétrés comme des listes, des ensembles) qui peuvent être "cartographiés". Pour être précis, un foncteur f est équipé de (a -> b) -> (f a -> f b) . Cela a des origines dans la catégorie de la théorie. L'article Wikipedia auquel vous avez fait référence est cet usage.

  class Functor f where
      fmap :: (a -> b) -> (f a -> f b)
  
  instance Functor [] where      -- lists are a functor
      fmap = map
  
  instance Functor Maybe where   -- Maybe is option in Haskell
      fmap f (Just x) = Just (f x)
      fmap f Nothing = Nothing
  
  fmap (+1) [2,3,4]   -- this is [3,4,5]
  fmap (+1) (Just 5)  -- this is Just 6
  fmap (+1) Nothing   -- this is Nothing
  

ainsi, il s'agit d'un type particulier d'un constructeur de type, et a peu à faire avec des foncteurs en Ocaml!

• dans les langues impératives, c'est un pointeur pour fonctionner.

en OCaml, c'est un module paramétré.

si vous connaissez C++, pensez à un foncteur OCaml comme un modèle. C++ n'a que des modèles de classe, et les foncteurs fonctionnent à l'échelle du module.

un exemple de functor est Map.Make; module StringMap = Map.Make (String);; construit un module de carte qui fonctionne avec des cartes à clé.

vous ne pouviez pas obtenir quelque chose comme StringMap avec juste du polymorphisme; vous devez faire quelques hypothèses sur les clés. chaîne module contient les opérations (comparaison, etc) sur un type de chaîne entièrement commandé, et le functor se liera avec les opérations que le module de chaîne contient. Vous pourriez faire quelque chose de similaire avec la programmation orientée objet, mais vous auriez méthode indirecte au-dessus.

vous avez pas mal de bonnes réponses.

Un foncteur, dans le sens mathématique, est un type spécial de fonction sur une algèbre. Il s'agit d'une fonction minimale qui établit une correspondance entre une algèbre et une autre. La "minimalité" est exprimée par les lois de fonctionnement.

Il y a deux façons de regarder cette. Par exemple, les listes sont des foncteurs sur un certain type. C'est-à-dire, étant donné une algèbre sur un type 'a', vous pouvez générer une algèbre compatible de listes contenant des choses de type "a". (Par exemple: la carte qui prend un élément dans une liste unique le contenant: f (A) = [a]) encore une fois, la notion de compatibilité est exprimée par les lois de functor.

d'autre part, compte tenu d'un functeur f "sur" un type a, (c'est-à-dire, f A est le résultat de l'application du functeur f à l'algèbre de type a), et de la fonction de g: A - > b, Nous pouvons calculer un nouveau functeur F = (fmap g) qui correspond à f A à f B. En bref, fmap est la partie de f que les cartes "foncteur parties" à "foncteur pièces", et g est la partie de la fonction que les cartes de "l'algèbre des parties" à "l'algèbre de parties". Elle prend une fonction, un foncteur, et une fois terminé, il EST un foncteur.

il peut sembler que différentes langues utilisent des notions différentes de fonctions, mais elles ne le sont pas. Ils utilisent des foncteurs sur des algèbres différentes. OCamls a une algèbre de modules, et les foncteurs sur cette algèbre vous permettent d'attacher de nouvelles déclarations à un module dans un " compatible" façon.

Un Haskell foncteur n'est PAS un type de classe. C'est un type de données avec une variable libre qui satisfait la classe type. Si vous êtes prêt à creuser dans les entrailles d'un type de données (sans variables libres), vous pouvez réinterpréter un type de données comme un foncteur sur une algèbre sous-jacente. Par exemple:

données F = F Int

est isomorphe à la classe des Ints. Donc F, en tant que constructeur de valeurs, est une fonction qui établit une correspondance entre Int et F Int, un équivalent algèbre. C'est un foncteur. D'autre part, vous n'obtenez pas fmap gratuitement ici. C'est à ça que sert la correspondance des motifs.

Foncteurs sont bonnes pour la "fixation" des choses à des éléments de algèbres, dans un algébriquement compatible.

il y a un assez bon exemple dans le livre D'O'Reilly OCaml qui est sur le site Web de L'Inria (qui, au moment d'écrire ceci est malheureusement en baisse). J'ai trouvé un exemple très similaire dans ce livre utilisé par caltech: Introduction à OCaml (lien pdf) . La section pertinente est le chapitre sur les foncteurs (page 139 dans le livre, page 149 dans le PDF).

dans le livre ils ont un functor appelé MakeSet qui crée une structure de données qui se compose d'une liste, et pour ajouter un élément, de déterminer si un élément est dans la liste, et de trouver l'élément. La fonction de comparaison qui est utilisée pour déterminer si elle est dans/pas dans l'ensemble a été paramétrée (ce qui fait de MakeSet un functor au lieu d'un module).

ils ont également un module qui implante la fonction de comparaison de sorte qu'il fait une comparaison de chaîne de caractères insensible à la casse.

en utilisant le foncteur et le module qui met en œuvre la comparaison qu'ils peuvent créer un nouveau module en une ligne:

module SSet = MakeSet(StringCaseEqual);;

qui crée un module pour une structure de données établie qui utilise des comparaisons non sensibles à la casse. Si vous voulez créer un ensemble qui a utilisé des comparaisons sensibles à la casse, alors vous auriez juste besoin d'implémenter un nouveau module de comparaison au lieu d'un nouveau module de structure de données.

Tobu a comparé des foncteurs à des gabarits en C++ qui je pense est tout à fait approprié.

la meilleure réponse à cette question se trouve dans" Typeclassopedia " de Brent Yorgey.

ce numéro de Monad Reader contient une définition précise de ce qu'est un foncteur ainsi que de nombreuses définitions d'autres concepts ainsi qu'un diagramme. (Monoïde, Applicative, Monade et d'autres concepts sont expliqués et mis en relation avec un foncteur).

http://haskell.org/sitewiki/images/8/85/TMR-Issue13.pdf

extrait de Typeclassopedia pour Functor: "Une simple intuition est qu'un Foncteur représente un "conteneur" de certains trier, avec la possibilité d'appliquer une fonction uniformément à chaque élément dans le conteneur "

mais vraiment toute la typeclassopedia est une lecture fortement recommandée qui est étonnamment facile. D'une certaine manière, vous pouvez voir la typeclass présentée ici comme un parallèle au modèle de conception dans l'objet dans le sens où ils vous donnent un vocabulaire pour un comportement donné ou capacité.

Cheers

voici un article sur les foncteurs d'un POV de programmation , suivi de plus spécifiquement comment ils surface dans les langages de programmation .

L'utilisation pratique d'un foncteur est une monade, et vous pouvez trouver de nombreux tutoriels sur les monades si vous regardez pour cela.

étant donné les autres réponses et ce que je vais poster maintenant, je dirais que c'est un mot plutôt surchargé, mais de toute façon...

pour un indice concernant le sens du mot "functor" dans Haskell, demandez à GHCi:

Prelude> :info Functor
class Functor f where
  fmap :: forall a b. (a -> b) -> f a -> f b
  (GHC.Base.<$) :: forall a b. a -> f b -> f a
        -- Defined in GHC.Base
instance Functor Maybe -- Defined in Data.Maybe
instance Functor [] -- Defined in GHC.Base
instance Functor IO -- Defined in GHC.Base

donc, fondamentalement, un functor à Haskell est quelque chose qui peut être cartographié. Une autre façon de dire que c'est qu'un foncteur est quelque chose qui peut être considéré comme un conteneur qui peut être demandé d'utiliser une fonction pour transformer la valeur qu'il contient; ainsi, pour les listes, fmap coïncide avec map , Maybe , fmap f (Just x) = Just (f x) , fmap f Nothing = Nothing etc.

Le Foncteur typeclass sous-section et la section sur les Foncteurs, les Foncteurs Applicatifs et Monoids de Apprendre que Vous avez un Haskell pour le Grand Bien donner quelques exemples de cas où ce concept est utile. (Résumé: beaucoup d'endroits! :- ))

notez que n'importe quel monad peut être traité comme un functeur, et en fait, comme Craig Stuntz le fait remarquer, les functeurs les plus souvent utilisés ont tendance à être des monades... OTOH, il est parfois commode de faire d'un type une instance du Functor typeclass sans se donner la peine d'en faire un Monad. (P. ex. dans le cas de ZipList de Control.Applicative , mentionné sur l'une des pages susmentionnées .)

dans un commentaire au haut-voté réponse , l'utilisateur Wei Hu demande:

je comprends à la fois ML-functors et Haskell-functors, mais manque le perspicacité pour les relier ensemble. Quelle est la relation entre ces deux, dans une catégorie de la théorie des sens?

Note : Je ne sais pas ML, alors s'il vous plaît pardonner et corriger toutes les erreurs connexes.

supposons d'abord que nous connaissons tous les définitions de "catégorie" et de "fonction".

une réponse compacte serait que" Haskell-functors "sont (endo-)functors F : Hask -> Hask tandis que" ML-functors "sont functors G : ML -> ML' .

ici, Hask est la catégorie formée par les types de Haskell et les fonctions entre eux, et de même ML et ML' sont des catégories définies par les structures ML.

Note : il y a quelques problèmes techniques avec faire Hask une catégorie, mais il y a des moyens de les contourner.

d'un point de vue théorique de catégorie, cela signifie qu'un Hask -functor est une carte F des types Haskell:

data F a = ...

accompagné d'une carte fmap des fonctions de Haskell:

instance Functor F where
    fmap f = ...

ML, c'est joli. de la même façon, bien qu'il n'y ait pas d'abstraction canonique fmap dont je suis conscient, alors définissons-en une:

signature FUNCTOR = sig
  type 'a f
  val fmap: 'a -> 'b -> 'a f -> 'b f
end

C'est-à-dire f cartes ML - types et fmap cartes ML - fonctions, so

functor StructB (StructA : SigA) :> FUNCTOR =
struct
  fmap g = ...
  ...
end

est un foncteur F: StructA -> StructB .

"Foncteur est mappage d'objets et de morphisms qui préserve la composition et de l'identité d'une catégorie."

permet de définir ce qu'est une catégorie ?

C'est un tas d'objets!

dessinez quelques points (pour l'instant 2 points, un est 'a' un autre est 'b') à l'intérieur d'un Encerclez et nommez ce cercle A (catégorie) pour l'instant.

que contient cette catégorie ?

Composition entre objets et fonction D'identité pour chaque objet.

ainsi, nous devons cartographier les objets et préserver la composition après avoir appliqué notre foncteur.

imaginons que 'A' soit notre catégorie qui a des objets ['a', 'b'] et qu'il existe un morphisme a - > b

maintenant, nous devons définir un functor qui peut mapper ces objets et morphismes dans une autre catégorie 'B'.

disons le functor est appelé 'peut-être'

data Maybe a = Nothing | Just a

Ainsi, La catégorie " B " ressemble à ceci.

dessinez un autre cercle, mais cette fois avec "peut-être a" et "peut-être b" au lieu de " a " et "b".

Tout semble bon et tous les objets sont mappés

' a 'est devenu' peut-être a 'et' b 'est devenu'peut-être b'.

mais le problème est que nous devons aussi cartographier le morphisme de " a " à "b".

qui signifie morphisme a - > b EN 'A' devrait correspondre au morphisme' peut-être a '- > 'peut-être b'

morphisme de a - > b s'appelle f, puis morphisme de 'peut-être a' - > 'peut-être b' s'appelle' fmap f '

permet maintenant de voir quelle fonction' f 'faisait dans 'A' et voir si nous pouvons la répliquer dans ' b '

définition de la fonction de 'f' dans 'Un':

f :: a -> b

F prend A et retourne b

définition de " f "dans " B":

f :: Maybe a -> Maybe b

F prend peut-être a et retourne peut-être b

permet de voir comment utiliser fmap pour mapper la fonction 'f' de 'A' de la fonction 'fmap f' dans le 'B'

définition de fmap

fmap :: (a -> b) -> (Maybe a -> Maybe b)
fmap f Nothing = Nothing
fmap f (Just x) = Just(f x)

alors, qu'est-ce qu'on fait ici ?

nous appliquons la fonction 'f' à 'x' qui est de type 'a'. L'appariement spécial de "rien" vient de la définition de Functor Maybe .

ainsi, nous avons cartographié nos objets [a, b] et morphismes [ f ] de la catégorie " A "à la catégorie "B".

C'Est Foncteur!

pour ne pas contredire les réponses théoriques ou mathématiques précédentes, mais un foncteur est aussi un objet (dans un langage de programmation orienté objet) qui n'a qu'une seule méthode et est effectivement utilisé comme une fonction.

un exemple est L'interface exécutable en Java, qui n'a qu'une seule méthode: exécuter.

considérons cet exemple, d'abord dans Javascript, qui a des fonctions de première classe:

[1, 2, 5, 10].map(function(x) { return x*x; });

sortie: [1, 4, 25, 100]

La méthode map prend une fonction et renvoie un nouveau tableau avec chaque élément étant le résultat de l'application de cette fonction à la valeur à la même position dans le tableau d'origine.

pour faire la même chose est Java, en utilisant un Functor, vous auriez d'abord besoin de définir une interface, dire:

public interface IntMapFunction {
  public int f(int x);
}

alors, si vous ajoutez une classe collection qui a une fonction de carte, vous pouvez faire:

myCollection.map(new IntMapFunction() { public int f(int x) { return x * x; } });

Ceci utilise une sous-classe en ligne de IntMapFunction pour créer un Functor, qui est l'équivalent OO de la fonction de L'exemple JavaScript précédent.

L'utilisation de Functors vous permet d'appliquer des techniques fonctionnelles dans un langage OO. Bien sûr, certains langages OO ont aussi un support direct pour les fonctions, donc ce n'est pas nécessaire.

référence: http://en.wikipedia.org/wiki/Function_object

Aperçu

dans la programmation fonctionnelle, un functor est essentiellement une construction de levage ordinaires unary fonctions (c.-à-d. ceux avec un argument) à des fonctions entre les variables de nouveaux types. Il est beaucoup plus facile d'écrire et de maintenir des fonctions simples entre des objets simples et d'utiliser des foncteurs pour les soulever, puis d'écrire manuellement des fonctions entre des objets containers compliqués. Outre l'avantage d' écrire des fonctions simples une seule fois et les réutiliser par l'intermédiaire de différents foncteurs.

exemples de fonctions: tableaux, fonctions" peut-être "et" l'un ou l'autre", futures (voir par exemple https://github.com/Avaq/Fluture ), et bien d'autres.

Illustration

considérez la fonction construisant le nom complet de la personne à partir du prénom et du nom de famille. Nous pourrions le définir comme fullName(firstName, lastName) en fonction de deux arguments, qui ne seraient toutefois pas appropriés pour les foncteurs qui traitent uniquement des fonctions d'un argument. Pour y remédier, nous collectons tous les arguments dans un seul objet name , qui devient maintenant l'argument unique de la fonction:

// In JavaScript notation
fullName = name => name.firstName + ' ' + name.lastName

que se passe-t-il si nous avons beaucoup de monde en bataille? Au lieu d'aller manuellement sur la liste, nous pouvons simplement réutiliser notre fonction fullName via la méthode map prévue pour les tableaux avec une seule ligne courte de code:

fullNameList = nameList => nameList.map(fullName)

et l'utiliser comme

nameList = [
    {firstName: 'Steve', lastName: 'Jobs'},
    {firstName: 'Bill', lastName: 'Gates'}
]

fullNames = fullNameList(nameList) 
// => ['Steve Jobs', 'Bill Gates']

qui fonctionnera, chaque fois que chaque entrée dans notre nameList est un objet fournissant à la fois firstName et lastName propriétés. Mais que faire si certains objets ne sont pas (ou même ne sont pas des objets)? Pour éviter les erreurs et rendre le code plus sûr, nous pouvons envelopper nos objets dans le type Maybe (se Par exemple https://sanctuary.js.org/#maybe-type ):

// function to test name for validity
isValidName = name => 
    (typeof name === 'object') 
    && (typeof name.firstName === 'string')
    && (typeof name.lastName === 'string')

// wrap into the Maybe type
maybeName = name => 
    isValidName(name) ? Just(name) : Nothing()

où Just(name) est un conteneur ne portant que des noms valides et Nothing() est la valeur spéciale utilisée pour tout le reste. Maintenant, au lieu d'interrompre (ou d'oublier) pour vérifier la validité de nos arguments, nous pouvons simplement réutiliser (Supprimer) notre fonction fullName originale avec une autre ligne de code, basée à nouveau sur la méthode map , cette fois prévue pour le type peut-être:

// Maybe Object -> Maybe String
maybeFullName = maybeName => maybeName.map(fullName)

et l'utiliser comme

justSteve = maybeName(
    {firstName: 'Steve', lastName: 'Jobs'}
) // => Just({firstName: 'Steve', lastName: 'Jobs'})

notSteve = maybeName(
    {lastName: 'SomeJobs'}
) // => Nothing()

steveFN = maybeFullName(justSteve)
// => Just('Steve Jobs')

notSteveFN = maybeFullName(notSteve)
// => Nothing()

Théorie Des Catégories

Un Foncteur dans "1519620920 Catégorie" Théorie est une carte entre les deux catégories en respectant la composition de leur morphisms. Dans un langage informatique , la principale catégorie d'intérêt est celui dont objets sont types (certains ensembles de valeurs), et dont morphismes sont des fonctions f:a->b d'un type a à un autre type b .

par exemple, prendre a pour être le String type, b le type de nombre, et f est la fonction mapping une chaîne dans sa longueur:

// f :: String -> Number
f = str => str.length

ici a = String représente l'ensemble de toutes les cordes et b = Number l'ensemble de tous les nombres. En ce sens, a et b représentent tous deux des objets catégorie (qui est étroitement liée à la catégorie des types, la différence étant essentielle ici). Dans la catégorie des ensembles, morphismes entre deux ensembles sont précisément toutes les fonctions du premier ensemble au second. Ainsi notre fonction de longueur f voici un morphisme de l'ensemble des cordes dans l'ensemble des nombres.

comme nous ne considérons que la catégorie des ensembles, les Functors " pertinents 1519630920" de lui dans lui-même sont des cartes envoyant des objets aux objets et des morphismes aux morphismes, qui satisfont certaines lois algébriques.

Array :: a => [a]

pure :: a -> [a]
pure = x => [x]

// a -> [a]
Array.map(f) = arr => arr.map(f)