Functional Language Features: Iterators and Closures

Post by lachlan-sneff » Wed, Jun 24, 2020, 3:17 PM UTC

variaga wrote: post #10

opnitro wrote: post #3

Earlier quoted context omitted.

I believe, on the pattern matching side, it has to do with the fact that it's a higher level feature that feels much more declarative. Inside of writing a sequence of instructions to check whether a list is 3 and the first two are equal, one writes the declarative syntax: (define (f x) (match x [`(,x ,x ,y) y] [_ #f]))

I'm sure it makes sense to someone well-versed in Rust syntax, but to an outsider like me that code looks like the kind of "line noise" that made me switch from perl to python. The procedural 'if x.len == 3 and x[0] == x[1]' seems a lot clearer as to what is actually being tested.

  fn f(x: &[i32]) -> bool {
      match x {
          [x, y, _] if x == y => true,
          _ => false,
      }
  }

Post by gameswithgo » Wed, Jun 24, 2020, 3:20 PM UTC

dathinab wrote: post #6

rectang wrote: post #2

> Programming in a functional style often includes using functions as values by passing them in arguments, returning them from other functions, assigning them to variables for later execution, and so forth. > ... > Other Rust features, such as pattern matching and enums, which we’ve covered in other chapters, are influenced by the functional style as well. What is it about pattern matching and enums that associates t…

> first popularized by certain functional languages Basically that. People associate all kinds of different thinks with the term functional programming. The only think in common is that it's focused on functions, including first class functions. For other thinks including things like (strict) immutability, lazy evaluation, syntax, algebraic data types, linear typing, etc. it is different from person to person weather…

Post by opnitro » Wed, Jun 24, 2020, 3:22 PM UTC

variaga wrote: post #10

opnitro wrote: post #3

Earlier quoted context omitted.

I believe, on the pattern matching side, it has to do with the fact that it's a higher level feature that feels much more declarative. Inside of writing a sequence of instructions to check whether a list is 3 and the first two are equal, one writes the declarative syntax: (define (f x) (match x [`(,x ,x ,y) y] [_ #f]))

I'm sure it makes sense to someone well-versed in Rust syntax, but to an outsider like me that code looks like the kind of "line noise" that made me switch from perl to python. The procedural 'if x.len == 3 and x[0] == x[1]' seems a lot clearer as to what is actually being tested.

Post by andrewg » Wed, Jun 24, 2020, 3:42 PM UTC

nicoburns wrote: post #11

rectang wrote: post #2

> Programming in a functional style often includes using functions as values by passing them in arguments, returning them from other functions, assigning them to variables for later execution, and so forth. > ... > Other Rust features, such as pattern matching and enums, which we’ve covered in other chapters, are influenced by the functional style as well. What is it about pattern matching and enums that associates t…

> Is it just that pattern matching and enums were first popularized by certain functional languages? Not only were Sum Types first popularised by functional languages, most imperative/OO languages still don't have them (although I'm not quite sure why not). E.g. none of Java/C#/C++ have them. Neither do Python/Ruby/JavaScript/PHP (although the need is somewhat reduced in dynamic languages)

  std::variant options;
  options = true;
  
  bool value = std::get(options);
  bool has_bool = std::holds_alternative(options);
  
  // or test which alternative is held
  if (auto i = std::get_if(&options)) {
    // do something with int
  } else if (auto b = std::get_if(&options)) {
    // do something with bool
  } else {
    // do something with double
  }

Post by nicoburns » Wed, Jun 24, 2020, 3:54 PM UTC

andrewg wrote: post #18

nicoburns wrote: post #11

Earlier quoted context omitted.

> Is it just that pattern matching and enums were first popularized by certain functional languages? Not only were Sum Types first popularised by functional languages, most imperative/OO languages still don't have them (although I'm not quite sure why not). E.g. none of Java/C#/C++ have them. Neither do Python/Ruby/JavaScript/PHP (although the need is somewhat reduced in dynamic languages)

C++17 does - it's called std::variant. std::variant options; options = true; bool value = std::get (options); bool has_bool = std::holds_alternative (options); // or test which alternative is held if (auto i = std::get_if (&options)) { // do something with int } else if (auto b = std::get_if (&options)) { // do something with bool } else { // do something with double }