Funksionele ontwikkeling en nie-funksionele programmering

Question

In my tweede jaar van die Universiteit van ons "geleer" maatskappy haskell, ek weet byna niks oor dit en nog minder oor funksionele ontwikkeling.

Wat is die funksionele ontwikkeling, waarom en/xor waar sou ek wil om dit te gebruik in plaas van die nie-funksionele programmering en is ek korrek om te dink dat C is'n nie-funksionele programmeertaal?

Answer 1

Een van die belangrikste kenmerk in 'n funksionele taal is die konsep van die eerste-klas funksies. Die idee is dat jy funksies kan slaag as parameters na ander funksies en terug te bring as waardes.

Funksionele ontwikkeling behels die skryf van kode wat nie staat verander nie. Die primêre rede hiervoor is sodat opeenvolgende oproepe na 'n funksie dieselfde resultaat sal oplewer. Jy kan funksionele kode te skryf in enige taal wat eerste-klas funksies ondersteun, maar daar is 'n paar tale, soos Haskell, wat nie toelaat dat jy staat verander. Trouens, is jy nie veronderstel is om te maak enige newe-effekte (soos die druk van teks) glad -. Wat klink soos dit kon heeltemal nutteloos wees

Haskell diens plaas 'n ander benadering tot IO: Monads. Dit is voorwerpe wat die vereiste IO operasie bevat wat uitgevoer moet word deur die hoogste vlak van jou tolk. Op 'n ander vlak is hulle eenvoudig voorwerpe in die stelsel.

Watter voordele hou funksionele programmering te verskaf? Funksionele programmering laat kodering met minder potensiaal vir foute omdat elke komponent is heeltemal geïsoleer. Ook moet julle met rekursie en die eerste-klas funksies toelaat vir 'n eenvoudige bewyse van korrektheid wat tipies weerspieël die struktuur van die kode.

Answer 2

Wat is die funksionele programmering

Daar is twee verskillende definisies van "funksionele ontwikkeling" in die algemeen gebruik word vandag:

Die ouer definisie (oorsprong van Lisp) is dat funksionele ontwikkeling is oor programmering met behulp van eerste-klas funksies, bv.waar funksies behandel word soos enige ander waarde, sodat jy kan slaag funksies soos argumente aan ander funksies en funksie kan terugkeer funksies onder hul terugkeer waardes.Dit kulmineer in die gebruik van hoër-orde-funksies soos map en reduce (jy kan gehoor het van mapReduce as'n enkele operasie gebruik word swaar deur Google en, verrassend, dit is'n naby familielid!).Die .NETTO tipes System.Func en System.Action maak hoër-orde-funksies wat beskikbaar is in C#.Hoewel currying is onprakties in C#, funksies wat aanvaar ander funksies soos argumente is algemeen, bv.die Parallel.For funksie.

Die jonger definisie (gewild gemaak deur die maatskappy haskell) is dat funksionele ontwikkeling is ook oor die vermindering van en die beheer van newe-effekte, insluitend mutasie, d. w. sdie skryf van programme wat probleme op te los deur die saamstel van uitdrukkings.Dit is meer algemeen bekend as "suiwer funksionele ontwikkeling".Dit is moontlik gemaak deur baie verskillende benaderings tot die data strukture genoem "suiwer funksionele data strukture".Een probleem is dat die vertaling van die tradisionele noodsaaklik algoritmes te gebruik suiwer funksionele data strukture tipies maak prestasie 10x erger.Maatskappy haskell is die enigste oorlewende suiwer funksionele programmeertaal maar die konsepte het ingesluip in die hoofstroom programmering met biblioteke soos Linq op .NETTO.

waar sou ek wil om dit te gebruik in plaas van die nie-funksionele programmering

Oral.Lambdas in C# het nou gedemonstreer groot voordele.C++11 het lambdas.Daar is geen verskoning om nie te gebruik hoër-orde-funksies nou.As jy kan gebruik om'n taal soos F# jy sal ook voordeel trek uit tipe inferensie, outomatiese veralgemening, currying en gedeeltelike aansoek (sowel as baie van die ander taal funksies!).

is ek korrek om te dink dat C is'n nie-funksionele programmeertaal?

Ja.C is'n prosedurele taal.Egter, jy kan kry'n paar van die voordeel van funksionele programmering deur gebruik te maak van die funksie wysers en void * in C.

Answer 3

Dalk die moeite werd uitcheck hierdie artikel op F# "101" op die Wetboek Mag onlangs gepos.

Ook, Dustin Campbell het'n groot blog waar hy geplaas baie artikels op sy avonture op die kry tot en met spoed met F#..

Ek hoop jy vind dit nuttig :)

EDIT:

Ook, net om by te voeg, het my begrip van die funksionele ontwikkeling is dat alles is'n funksie, of parameters om'n funksie, eerder as gevalle/stateful voorwerpe..Maar ek kan verkeerd wees F# is iets wat ek sterf om te kry in, maar het net nie die tyd!:)

Answer 4

Johannes die Statistikus se voorbeeld kode nie funksionele programmering wys, want as jy doen funksionele programmering, die sleutel is dat die kode nie Geen opdragte (record = thingConstructor(t) is 'n taak), en dit het geen newe-effekte (localMap.put(record) is 'n verklaring met 'n newe-effek). As gevolg van hierdie twee beperkinge, alles wat 'n funksie nie ten volle gevang deur sy argumente en sy terugkeer waarde. Herskryf die Statistikus se kode die manier waarop dit sou hê om te kyk, as jy wou 'n funksionele taal met behulp van C ++ navolg:

RT getOrCreate(const T thing, 
                  const Function<RT<T>> thingConstructor, 
                  const Map<T,RT<T>> localMap) {
    return localMap.contains(t) ?
        localMap.get(t) :
        localMap.put(t,thingConstructor(t));
}

As gevolg van die geen newe-effekte reël, elke stelling is deel van die opbrengs waarde (vandaar return kom eerste ), en elke stelling is 'n uitdrukking. In tale wat funksionele programmering toe te pas, is die return navraag geïmpliseer, en die as verklaring optree soos C ++ se ?: operateur.

Ook, alles is onveranderlik, so localMap.put het om 'n nuwe kopie van localMap en stuur dit terug te skep, in plaas van die wysiging van die oorspronklike localMap , die manier waarop 'n normale C ++ of Java program sou doen. Afhangende van die struktuur van localMap, kan die afskrif hergebruik wysers in die oorspronklike, die vermindering van die hoeveelheid data wat moet kopieer.

Van die voordele van funksionele programmering sluit in die feit dat funksionele programme is korter, en dit is makliker om 'n funksionele program verander (want daar is geen verskuilde globale effekte in ag te neem), en dit is makliker om die program te kry reg in die eerste plek.

Maar funksionele programme is geneig om stadig te hardloop (as gevolg van al die kopiëring hulle hoef te doen), en hulle is geneig om goed te kommunikeer met ander programme, bedryfstelsel prosesse, of bedryfstelsels, wat handel in die geheue-adresse, klein-endian blokke van grepe, en ander masjien-spesifieke, nie-funksionele stukkies. Die graad van noninteroperability geneig om omgekeerd gekorreleer met die graad van funksionele suiwerheid, en die strengheid van die tipe stelsel.

Die meer gewilde funksionele tale het baie, baie streng tipe stelsels. In OCAML, kan jy nie eens meng heelgetal en swaai-punt wiskunde, of dieselfde operateurs gebruik (+ is vir die toevoeging van heelgetalle, +. Is vir die toevoeging van dryf). Dit kan óf 'n voordeel of 'n nadeel wees, afhangende van hoe hoog jy waardeer die vermoë van 'n tipe checker om sekere vorme van foute te vang.

Funksionele tale is ook geneig om baie groot runtime omgewings het. Haskell is 'n uitsondering (GHC executables is amper so groot soos C programme, beide tydens kompilering-time en runtime), maar SML, Common Lisp, en Skema programme vereis altyd ton van die geheue.

Answer 5

Ja jy is korrek in te dink dat C is 'n nie-funksionele taal is. C is 'n proses taal.

Answer 6

Ek verkies om funksionele programmering te gebruik om myself te red herhaal werk, deur die maak van 'n meer abstrakte weergawe en dan met behulp van die plaas. Kom ek gee 'n voorbeeld. In Java, ek vind myself dikwels die skep van kaarte om strukture te teken, en dus skryf getOrCreate strukture.

SomeKindOfRecord<T> getOrCreate(T thing) { 
    if(localMap.contains(t)) { return localMap.get(t); }
    SomeKindOfRecord<T> record = new SomeKindOfRecord<T>(t);
    localMap = localMap.put(t,record);
    return record; 
}

Dit gebeur baie dikwels. Nou, in 'n funksionele taal wat ek kon skryf

RT<T> getOrCreate(T thing, 
                  Function<RT<T>> thingConstructor, 
                  Map<T,RT<T>> localMap) {
    if(localMap.contains(t)) { return localMap.get(t); }
    RT<T> record = thingConstructor(t);
    localMap = localMap.put(t,record);
    return record; 
}

en ek sal nooit 'n nuwe een van hierdie weer skryf, kon ek dit laat beërwe. Maar ek kan 'n mens beter as erfgename doen, ek kon sê in die konstruktor van hierdie ding

getOrCreate = myLib.getOrCreate(*,
                                SomeKindOfRecord<T>.constructor(<T>), 
                                localMap);

(waar * is 'n soort van "laat hierdie parameter oop" notasie, wat is 'n soort van currying)

en dan die plaaslike getOrCreate is presies dieselfde as dit sou gewees het as ek geskryf het uit die hele ding, in een lyn, met geen erfdeel afhanklikhede.

Answer 7

As jy op soek is na 'n goeie teks op F #

Expert F # is mede-geskryf deur Don Syme. Skepper van F #. Hy het op generiese in NET spesifiek sodat hy kon skep F #.

F # is gemodelleer na OCaml so enige OCaml teks sal jou help om te leer F # sowel.

Answer 8

Ek vind Wat is funksioneel Programmering? om wees bruikbare

  

Funksionele ontwikkeling is oor die skryf van suiwer funksies, oor die verwydering van   verborge en uitgange so ver as wat ons kan, sodat soveel van ons   -kode as moontlik beskryf net 'n verhouding tussen insette en   uitsette.

Verkies eksplisiete when param

public Program getProgramAt(TVGuide guide, int channel, Date when) {
  Schedule schedule = guide.getSchedule(channel);

  Program program = schedule.programAt(when);

  return program;
}

oor

public Program getCurrentProgram(TVGuide guide, int channel) {
  Schedule schedule = guide.getSchedule(channel);

  Program current = schedule.programAt(new Date());

  return current;
}

  

'n funksionele taal is aktief vyandig teenoor newe-effekte. Newe-effekte is kompleksiteit en kompleksiteit is foute en foute is die duiwel. 'N Funksionele taal sal jou help om vyandig teenoor ook newe-effekte wees.