Yahoo Web Search

Search results

1. Top results related to what is the difference between procedural and functional programming examples

   • What is the difference between procedural programming and functional programming?

     Top Answer

     Answered Aug 06, 2019 · 182 votes

     A functional language (ideally) allows you to write a mathematical function, i.e. a function that takes n arguments and returns a value. If the program is executed, this function is logically evaluated as needed.1

     A procedural language, on the other hand, performs a series of sequential steps. (There's a way of transforming sequential logic into functional logic called continuation passing style.)

     As a consequence, a purely functional program always yields the same value for an input, and the order of evaluation is not well-defined; which means that uncertain values like user input or random values are hard to model in purely functional languages.

     1 As everything else in this answer, that’s a generalisation. This property, evaluating a computation when its result is needed rather than sequentially where it’s called, is known as “laziness”. Not all functional languages are actually universally lazy, nor is laziness restricted to functional programming. Rather, the description given here provides a “mental framework” to think about different programming styles that are not distinct and opposite categories but rather fluid ideas.

     Other Answers

     Answered Nov 28, 2012 · 109 votes

     I've never seen this definition given elsewhere, but I think this sums up the differences given here fairly well:

     Functional programming focuses on expressions

     Procedural programming focuses on statements

     Expressions have values. A functional program is an expression who's value is a sequence of instructions for the computer to carry out.

     Statements don't have values and instead modify the state of some conceptual machine.

     In a purely functional language there would be no statements, in the sense that there's no way to manipulate state (they might still have a syntactic construct named "statement", but unless it manipulates state I wouldn't call it a statement in this sense). In a purely procedural language there would be no expressions, everything would be an instruction which manipulates the state of the machine.

     Haskell would be an example of a purely functional language because there is no way to manipulate state. Machine code would be an example of a purely procedural language because everything in a program is a statement which manipulates the state of the registers and memory of the machine.

     The confusing part is that the vast majority of programming languages contain both expressions and statements, allowing you to mix paradigms. Languages can be classified as more functional or more procedural based on how much they encourage the use of statements vs expressions.

     For example, C would be more functional than COBOL because a function call is an expression, whereas calling a sub program in COBOL is a statement (that manipulates the state of shared variables and doesn't return a value). Python would be more functional than C because it allows you to express conditional logic as an expression using short circuit evaluation (test && path1 || path2 as opposed to if statements). Scheme would be more functional than Python because everything in scheme is an expression.

     You can still write in a functional style in a language which encourages the procedural paradigm and vice versa. It's just harder and/or more awkward to write in a paradigm which isn't encouraged by the language.

     Other Answers

     Answered May 07, 2023 · 106 votes

     Basically the two styles, are like Yin and Yang. One is organized, while the other chaotic. There are situations when Functional programming is the obvious choice, and other situations were Procedural programming is the better choice. This is why there are at least two languages that have recently come out with a new version, that embraces both programming styles. ( Perl 6 and D 2 )

     Procedural:

     • The output of a routine does not always have a direct correlation with the input.
     • Everything is done in a specific order.
     • Execution of a routine may have side effects.
     • Tends to emphasize implementing solutions in a linear fashion.

     Perl 6

     sub factorial ( UInt:D $n is copy ) returns UInt {- # modify "outside" state state $call-count++; # in this case it is rather pointless as # it can't even be accessed from outside- my $result = 1;- loop ( ; $n > 0 ; $n-- ){- $result *= $n;- }- return $result;}-

     D 2

     int factorial( int n ){- int result = 1;- for( ; n > 0 ; n-- ){ result *= n; }- return result;}-

     Functional:

     • Often recursive.
     • Always returns the same output for a given input.
     • Order of evaluation is usually undefined.
     • Must be stateless. i.e. No operation can have side effects.
     • Good fit for parallel execution
     • Tends to emphasize a divide and conquer approach.
     • May have the feature of Lazy Evaluation.

     Haskell

     ( copied from Wikipedia );

     fac :: Integer -> Integer-fac 0 = 1fac n | n > 0 = n * fac (n-1)-

     or in one line:

     fac n = if n > 0 then n * fac (n-1) else 1-

     Perl 6

     proto sub factorial ( UInt:D $n ) returns UInt {*}-multi sub factorial ( 0 ) { 1 }multi sub factorial ( $n ) { $n * samewith $n-1 } # { $n * factorial $n-1 }-

     D 2

     pure int factorial( invariant int n ){ if( n <= 1 ){ return 1; }else{ return n * factorial( n-1 ); }}-

     Side note:

     Factorial is actually a common example to show how easy it is to create new operators in Perl 6 the same way you would create a subroutine. This feature is so ingrained into Perl 6 that most operators in the Rakudo implementation are defined this way. It also allows you to add your own multi candidates to existing operators.

     sub postfix:< ! > ( UInt:D $n --> UInt ) is tighter(&infix:<*>) { [*] 2 .. $n }-say 5!; # 120␤-

     This example also shows range creation (2..$n) and the list reduction meta-operator ([ OPERATOR ] LIST) combined with the numeric infix multiplication operator. (*) It also shows that you can put --> UInt in the signature instead of returns UInt after it.

     ( You can get away with starting the range with 2 as the multiply "operator" will return 1 when called without any arguments )

     Check all answers on Stack Overflow

     1/5

   • What is the difference between functional programming and declarative programming?

     Top Answer

     Answered Apr 12, 2018 · 7 votes

     A non-functional declarative language is PROLOG. Programming in PROLOG is stating a number of facts, and then ask questions, which the system tries to verify or deny.

     Example:

     human(socrates). // "Socrates is a human."mortal(X) :- human(X). // "If X is a human, then X is mortal" or // "All humans are mortal."? mortal(socrates) // Is Socrates mortal?Yes.? mortal(X) // Who is mortal?socrates ? mortal(pythagoras). No. // since system doesn't know about any human except Socrates

     Another well known language that is declarative, but not functional, is SQL.

     Note that there are not only no functions as first class values. In the PROLOG example, there are no functions at all! To be sure, both SQL and PROLOG have some built-in functions, but have no way to let you write your own functions. One could think that the rule

     mortal(X) :- human(X).-

     is a function, but it isn't, it is an inference rule. Hence, declarative, non-functional languages.

     For the second part of your question: it is certainly possible to write imperative code in functional programming languages. Simon Peyton Jones once stated that he thinks that Haskell is the finest imperative programming language in the world. (And this was only a half joke.)

     Example:

     main = do print "Enter a number" line <- getLine print (succ (read line :: Int))

     Check all answers on Stack Overflow

     2/5

   • What is the difference between declarative and procedural programming paradigms?

     Top Answer

     Answered Sep 10, 2018 · 127 votes

     Imperative

     There are several sub-paradigms of the imperative programming paradigm, such as the procedural or the object-oriented programming paradigms.

     In the imperative programming paradigm, you describe the algorithm step-by-step, at various degrees of abstraction.

     Examples of programming languages which support the procedural paradigm:

     • C (and most other legacy languages)
     • PHP, mostly
     • In some sense, all major languages

     Object-Oriented

     It typically refers to languages that exhibit a hierarchy of types that inherit both methods and state from base types to derived types, but also includes the unusual prototype-based JavaScript.

     Examples of programming languages which support the OO paradigm:

     • Java

     Declarative

     There are several sub-paradigms of the declarative programming paradigm, such as the functional or the logic programming paradigms.

     In the declarative programming paradigm, you describe a result or a goal, and you get it via a "black box". The opposite of imperative.

     Examples of programming languages which support the declarative programming paradigm:

     • yacc
     • Treetop
     • SQL
     • Regular Expressions
     • lex
     • XSLT
     • markup, troff, CSS, VHDL

     Functional

     Functional programming emphasizes the application of functions without side effects and without mutable state. The declarative systems above exhibit certain aspects of functional programming.

     Examples of programming languages which support the declarative functional paradigm:

     • Haskell
     • OCaml
     • Scheme
     • Erlang
     • F#
     • Scala

     Other Answers

     Answered Nov 28, 2012 · 109 votes

     I've never seen this definition given elsewhere, but I think this sums up the differences given here fairly well:

     Functional programming focuses on expressions

     Procedural programming focuses on statements

     Expressions have values. A functional program is an expression who's value is a sequence of instructions for the computer to carry out.

     Statements don't have values and instead modify the state of some conceptual machine.

     In a purely functional language there would be no statements, in the sense that there's no way to manipulate state (they might still have a syntactic construct named "statement", but unless it manipulates state I wouldn't call it a statement in this sense). In a purely procedural language there would be no expressions, everything would be an instruction which manipulates the state of the machine.

     Haskell would be an example of a purely functional language because there is no way to manipulate state. Machine code would be an example of a purely procedural language because everything in a program is a statement which manipulates the state of the registers and memory of the machine.

     The confusing part is that the vast majority of programming languages contain both expressions and statements, allowing you to mix paradigms. Languages can be classified as more functional or more procedural based on how much they encourage the use of statements vs expressions.

     For example, C would be more functional than COBOL because a function call is an expression, whereas calling a sub program in COBOL is a statement (that manipulates the state of shared variables and doesn't return a value). Python would be more functional than C because it allows you to express conditional logic as an expression using short circuit evaluation (test && path1 || path2 as opposed to if statements). Scheme would be more functional than Python because everything in scheme is an expression.

     You can still write in a functional style in a language which encourages the procedural paradigm and vice versa. It's just harder and/or more awkward to write in a paradigm which isn't encouraged by the language.

     Other Answers

     Answered May 07, 2023 · 106 votes

     Basically the two styles, are like Yin and Yang. One is organized, while the other chaotic. There are situations when Functional programming is the obvious choice, and other situations were Procedural programming is the better choice. This is why there are at least two languages that have recently come out with a new version, that embraces both programming styles. ( Perl 6 and D 2 )

     Procedural:

     • The output of a routine does not always have a direct correlation with the input.
     • Everything is done in a specific order.
     • Execution of a routine may have side effects.
     • Tends to emphasize implementing solutions in a linear fashion.

     Perl 6

     sub factorial ( UInt:D $n is copy ) returns UInt { # modify "outside" state state $call-count++; # in this case it is rather pointless as # it can't even be accessed from outside my $result = 1; loop ( ; $n > 0 ; $n-- ){ $result *= $n; } return $result;}

     D 2

     int factorial( int n ){ int result = 1; for( ; n > 0 ; n-- ){ result *= n; } return result;}

     Functional:

     • Often recursive.
     • Always returns the same output for a given input.
     • Order of evaluation is usually undefined.
     • Must be stateless. i.e. No operation can have side effects.
     • Good fit for parallel execution
     • Tends to emphasize a divide and conquer approach.
     • May have the feature of Lazy Evaluation.

     Haskell

     ( copied from Wikipedia );

     fac :: Integer -> Integerfac 0 = 1fac n | n > 0 = n * fac (n-1)

     or in one line:

     fac n = if n > 0 then n * fac (n-1) else 1

     Perl 6

     proto sub factorial ( UInt:D $n ) returns UInt {*}multi sub factorial ( 0 ) { 1 }multi sub factorial ( $n ) { $n * samewith $n-1 } # { $n * factorial $n-1 }

     D 2

     pure int factorial( invariant int n ){ if( n <= 1 ){ return 1; }else{ return n * factorial( n-1 ); }}

     Side note:

     Factorial is actually a common example to show how easy it is to create new operators in Perl 6 the same way you would create a subroutine. This feature is so ingrained into Perl 6 that most operators in the Rakudo implementation are defined this way. It also allows you to add your own multi candidates to existing operators.

     sub postfix:< ! > ( UInt:D $n --> UInt ) is tighter(&infix:<*>) { [*] 2 .. $n }say 5!; # 120␤

     This example also shows range creation (2..$n) and the list reduction meta-operator ([ OPERATOR ] LIST) combined with the numeric infix multiplication operator. (*) It also shows that you can put --> UInt in the signature instead of returns UInt after it.

     ( You can get away with starting the range with 2 as the multiply "operator" will return 1 when called without any arguments )

     Check all answers on Stack Overflow

     3/5

   • What's the difference between functional, structured and procedural programming?

     Top Answer

     Answered Dec 09, 2010 · 46 votes

     Structured programming is an old term that I think would encompass functional, procedural, and much else. It basically means using explicit control-flow structures rather than jumping about directly from instruction to instruction.

     Functional and procedural programming are both, in that sense, structured paradigms. Functional programming is also declarative programming -- the structure given to your code corresponds to its meaning -- a program is a function that changes the state of the world. Procedural programming is what you'd consider "typical" programming in any C language or its descendants, including OO languages such as Java and C++. A program is a series of instructions, to be executed serially, and invoking subprocedures along the way.

     Or, as it has been famously described:

     Functional programming is like describing your problem to a mathematician. Imperative programming is like giving instructions to an idiot.

     --- arcus, #scheme on Freenode-

     Check all answers on Stack Overflow

     4/5

   • What is the difference between functional and non-functional requirements?

     Top Answer

     Answered Jan 04, 2019 · 563 votes

     A functional requirement describes what a software system should do, while non-functional requirements place constraints on how the system will do so.

     Let me elaborate.

     An example of a functional requirement would be:

     • A system must send an email whenever a certain condition is met (e.g. an order is placed, a customer signs up, etc).

     A related non-functional requirement for the system may be:

     • Emails should be sent with a latency of no greater than 12 hours from such an activity.

     The functional requirement is describing the behavior of the system as it relates to the system's functionality. The non-functional requirement elaborates a performance characteristic of the system.

     Typically non-functional requirements fall into areas such as:

     • Accessibility
     • Capacity, current and forecast
     • Compliance
     • Documentation
     • Disaster recovery
     • Efficiency
     • Effectiveness
     • Extensibility
     • Fault tolerance
     • Interoperability
     • Maintainability
     • Privacy
     • Portability
     • Quality
     • Reliability
     • Resilience
     • Response time
     • Robustness
     • Scalability
     • Security
     • Stability
     • Supportability
     • Testability

     A more complete list is available at Wikipedia's entry for non-functional requirements.

     Non-functional requirements are sometimes defined in terms of metrics (i.e. something that can be measured about the system) to make them more tangible. Non-functional requirements may also describe aspects of the system that don't relate to its execution, but rather to its evolution over time (e.g. maintainability, extensibility, documentation, etc.).

     Check all answers on Stack Overflow

     5/5

   Show moreShow less

2. scoutapm.com › blog › functional-vs-procedural-vs-oopFunctional vs. Procedural vs. OOP | Scout APM Blog

   scoutapm.com › blog › functional-vs-procedural-vs-oop

   • Cached

   Mar 4, 2021 · Languages that follow Procedural Programming. Some of the common languages that use procedural programming are: Fortran; Pascal; C; Basic; Functional Programming. Functional programming is all about organizing your code around the idea of using functions.

   • Author: Prince Sinha

3. stackoverflow.com › questions › 23277What is the difference between procedural programming and ...

   stackoverflow.com › questions › 23277

   • Cached

   Functional programming focuses on expressions. Procedural programming focuses on statements. Expressions have values. A functional program is an expression who's value is a sequence of instructions for the computer to carry out. Statements don't have values and instead modify the state of some conceptual machine.

   Code sample

   sub postfix:< ! > ( UInt:D $n --> UInt )

     is tighter(&infix:<*>)

     { [*] 2 .. $n }

   say 5!; # 120?

   See more on stackoverflow

4. People also ask

   What is the difference between procedural code and functional programming?

   • Larger Programs: Often results in larger programs than procedural code. The basic units of functional programming are functions. In this paradigm, functions are first-class citizens of the language. We can assign a function to a variable, pass it as an argument or return it from a function just like a regular variable.

   OOP vs Functional vs Procedural - Scaler Topics

   www.scaler.com/topics/java/oop-vs-functional-vs-procedural/

   See all results for this question

   Can procedural programming include functions?

   • As you can see, procedural programming can also include functions (from functional programming) and that is not forbidden. This is because the idea here isn’t to absolutely shun functions, or objects, or any other paradigm – those structures serve their own purpose.

   Functional vs. Procedural vs. OOP | Scout APM Blog

   scoutapm.com/blog/functional-vs-procedural-vs-oop

   See all results for this question

   What's the difference between a procedural language and a functional language?

   • Some functional languages have what is called Lazy Evaluation. Which means a function is not executed until the value is needed. Until that time the function itself is what is passed around. Procedural languages are step 1 step 2 step 3... if in step 2 you say add 2 + 2, it does it right then.

   glossary - What is the difference between procedural programming and

   stackoverflow.com/questions/23277/what-is-the-difference-between-procedural-programming-and-functional-programming

   See all results for this question

   What is the basic construct of procedural programming?

   • The basic construct of procedural programming is blocks of code known as procedures or routines. Procedures contain sequence instructions that specify a computational step carried out upon execution. Scoping: Scoping refers to a concept that sets the locality of entities (objects) in a procedural program.

   OOP vs Functional vs Procedural - Scaler Topics

   www.scaler.com/topics/java/oop-vs-functional-vs-procedural/

   See all results for this question

5. stackoverflow.com › questions › 5226055Truly understanding the difference between procedural and ...

   stackoverflow.com › questions › 5226055

   • Cached

   One clear difference between the two programming paradigms is state. In Functional Programming, state is avoided. Simply put, there will be no variable that is assigned a value. Example: def double(x): return x * 2 def doubleLst(lst): return list(map(double, action)) However, Procedural Programming uses state. Example:

   • Functional Programming Functional programming refers to the ability to treat functions as values. Let's consider an analogy with "regular" values....
   • The real difference between functional and imperative programming is the mindset - imperative programmers are thinking of variables and blocks of m...
   • Isn't that the same exact case for procedural programming? No, because procedural code can have side-effects. For example, it can store state betw...
   • I disagree with WReach's answer. Let's deconstruct his answer a bit to see where the disagreement comes from. First, his code: function allOdd(word...
   • In procedural paradigm (shall I say "structured programming" instead?), you have shared mutable memory and instructions which read/write it in some...
   • The Charming Python: Functional programming in Python from IBM Developerworks really helped me to understand the difference. Especially for so...
   • In functional programming in order to reason about the meaning of a symbol (variable or function name) you only really need to know 2 things -- cur...
   • I've recently been thinking of the difference in terms of the Expression Problem . Phil Wadler's description is oft-cited, but the accepted ans...

6. github.com › readme › guidesFunctional Programming 101 · GitHub

   github.com › readme › guides

   • Cached

   What is functional programming? There are three “types” of programming that you may or may not know: procedural programming, object-oriented programming, and functional programming. I’ll focus on the latter two. In object-oriented programming (OOP), you create “objects” (hence the name), which are structures that have data and methods.

7. www.scaler.com › oop-vs-functional-vs-proceduralOOP vs Functional vs Procedural - Scaler Topics

   www.scaler.com › oop-vs-functional-vs-procedural

   • Cached

   Apr 7, 2022 · Procedural programming organizes the code into chunks of procedures, Object-oriented code helps the programmer think of objects which represent a concept or real-world component, and Functional programming orients the programmer in the world of pure functions.

8. www.freecodecamp.org › news › an-introduction-toProgramming Paradigms – Paradigm Examples for Beginners

   www.freecodecamp.org › news › an-introduction-to

   • Cached

   May 2, 2022 · Procedural programming. Functional programming. Declarative programming. Object-oriented programming. Roundup. What is a Programming Paradigm? Programming paradigms are different ways or styles in which a given program or programming language can be organized.

9. skillapp.co › blog › exploring-the-differencesExploring the Differences – Functional vs Procedural Programming

   skillapp.co › blog › exploring-the-differences

   • Cached

   Procedural programming follows a step-by-step execution approach, where a program is organized into a sequence of procedures or functions. These procedures are executed in a predefined order, with each procedure manipulating data structures or invoking other procedures.