b'\n_START_ARTICLE_\nCombinador de ponto fixo\n_START_SECTION_\nFun\xc3\xa7\xc3\xa3o versus implementa\xc3\xa7\xc3\xa3o\n_START_PARAGRAPH_\nO combinador de ponto fixo pode ser definido em matem\xc3\xa1tica e, em seguida, implementado em outros linguagens. A matem\xc3\xa1tica geral define uma fun\xc3\xa7\xc3\xa3o com base em suas propriedades extensionais.\xc2\xa0Ou seja, duas fun\xc3\xa7\xc3\xb5es s\xc3\xa3o iguais se elas executam o mesmo mapeamento. O c\xc3\xa1lculo lambda e as linguagens de programa\xc3\xa7\xc3\xa3o consideram a fun\xc3\xa7\xc3\xa3o identidade como uma propriedade intensional. A identidade de fun\xc3\xa7\xc3\xb5es baseia-se na sua implementa\xc3\xa7\xc3\xa3o._NEWLINE_\xc2\xa0Uma fun\xc3\xa7\xc3\xa3o do c\xc3\xa1lculo lambda (ou termo) \xc3\xa9 uma implementa\xc3\xa7\xc3\xa3o de uma fun\xc3\xa7\xc3\xa3o matem\xc3\xa1tica. No c\xc3\xa1lculo lambda, h\xc3\xa1 uma s\xc3\xa9rie de combinadores (implementa\xc3\xa7\xc3\xb5es) que satisfazem a defini\xc3\xa7\xc3\xa3o matem\xc3\xa1tica de um combinador de ponto fixo.\n_START_SECTION_\nO que \xc3\xa9 um "combinador"?\n_START_PARAGRAPH_\nUm combinador \xc3\xa9 um tipo especial de fun\xc3\xa7\xc3\xa3o de alta ordem que pode ser usado na defini\xc3\xa7\xc3\xa3o de fun\xc3\xa7\xc3\xb5es sem a utiliza\xc3\xa7\xc3\xa3o de vari\xc3\xa1veis. Os combinadores podem ser combinados com os valores para seus lugares corretos na express\xc3\xa3o sem nunca nome\xc3\xa1-los como vari\xc3\xa1veis.\n_START_SECTION_\nImplementa\xc3\xa7\xc3\xa3o funcional pregui\xc3\xa7osa\n_START_PARAGRAPH_\nIEm uma linguagem que suporta avalia\xc3\xa7\xc3\xa3o pregui\xc3\xa7osa, como em Haskell, \xc3\xa9 poss\xc3\xadvel definir um combinador de ponto fixo usando a equa\xc3\xa7\xc3\xa3o que define o combinador de ponto fixo que \xc3\xa9 convencionalmente chamado fix. A defini\xc3\xa7\xc3\xa3o \xc3\xa9 dada aqui, seguido de alguns exemplos de uso._NEWLINE_ fix :: (a -> a) -> a_NEWLINE_ fix f = f (fix f)                -- Lambda lifted_NEWLINE_ -- alternative:_NEWLINE_ -- fix f = let x = f x in x      -- Lambda dropped_NEWLINE__NEWLINE_ fix (\\x -> 9)                    -- this evaluates to 9_NEWLINE_ factabs fact 0 = 1               -- factabs is F from the lambda calculus example_NEWLINE_ factabs fact x = x * fact (x-1)_NEWLINE_ (fix factabs) 5                  -- evaluates to 120\n_START_SECTION_\nImplementa\xc3\xa7\xc3\xa3o linguagem imperativa\n_START_PARAGRAPH_\nEste exemplo \xc3\xa9 uma implementa\xc3\xa7\xc3\xa3o ligeiramente interpretativa de um combinador de ponto fixo. A classe \xc3\xa9 usada para conter a fun\xc3\xa7\xc3\xa3o fix, chamada fixer. A fun\xc3\xa7\xc3\xa3o fix est\xc3\xa1 contida em uma classe que herda de fixer. A fun\xc3\xa7\xc3\xa3o fix acessa a fun\xc3\xa7\xc3\xa3o fixer em fun\xc3\xa7\xc3\xa3o virtual. Quanto \xc3\xa0 defini\xc3\xa7\xc3\xa3o funcional estrito, fix \xc3\xa9 dado explicitamente um par\xc3\xa2metro x extra, o que significa que a avalia\xc3\xa7\xc3\xa3o pregui\xc3\xa7osa n\xc3\xa3o \xc3\xa9 necess\xc3\xa1ria._NEWLINE_template <typename R, typename D>class fixer{public:_NEWLINE_    R fix(D x)_NEWLINE_    {_NEWLINE_        return f(x);_NEWLINE_    }private:_NEWLINE_    virtual R f(D) = 0;};class fact : public fixer<long, long>{_NEWLINE_    virtual long f(long x)_NEWLINE_    {_NEWLINE_        if (x == 0)_NEWLINE_        {_NEWLINE_            return 1;_NEWLINE_        }_NEWLINE_        return x * fix(x-1);_NEWLINE_    }};long result = fact().fix(5);\n_START_SECTION_\nTipo para o combinador Y\n_START_PARAGRAPH_\nEm linguagens de programa\xc3\xa7\xc3\xa3o que suportam tipos recursivos, \xc3\xa9 poss\xc3\xadvel tipar o combinador Y apropriadamente representando a recurs\xc3\xa3o no n\xc3\xadvel do tipo. A necessidade de auto-aplica\xc3\xa7\xc3\xa3o a vari\xc3\xa1vel X pode ser controlada utilizando um tipo (Rec a), (Rec a), o qual \xc3\xa9 definido de modo a ser isomorfo a (Rec a -> a)._NEWLINE__NEWLINE_Por exemplo, no c\xc3\xb3digo a seguir em Haskell, temos In e Out sendo os nomes das duas dire\xc3\xa7\xc3\xb5es do isomorfismo, com tipos:\xc2\xa0_NEWLINE_In :: (Rec a -> a) -> Rec aout :: Rec a -> (Rec a -> a)_NEWLINE_newtype Rec a = In { out :: Rec a -> a }y :: (a -> a) -> ay = \\f -> (\\x -> f (out x x)) (In (\\x -> f (out x x)))_NEWLINE_type \'a recc = In of (\'a recc -> \'a)let out (In x) = xlet y f = (fun x a -> f (out x x) a) (In (fun x a -> f (out x x) a))'