5 ms·

I let myself do a little bit of thinking and I guess this might be helpful when you are doing functional style pipes/chains but you can wrap the whole chain int

I let myself do a little bit of thinking and I guess this might be helpful when you are doing functional style pipes/chains but you can wrap the whole chain into a try except block. But the question is still there: why would you do that? Why the one would write functional code in a language that ain’t very good with maps and filters, has no lazy calculations and has no constants on language design level? Why would you set `Maybe[int]` type for a function argument? That’s an obvious overcomplication imo. Go and write some F# or Haskell. Well, the variety of options and flexibility is always good, but the language is fundamentally not meant to do it. From what I can see, it only makes sense in recreational programming, making some eye-pleasing code, but it all is just a workaround on a language that would not benefit from that code style. All above is strongly imo of course since I only write Python and am just learning Zig.

dragonwriter 5y ago
> Why the one would write functional code in a language that ain’t very good with maps and filters, has no lazy calculations and has no constants on language design level? Python is fine with maps and filters, and has lazy calculations.
- impoppy 5y ago
  Please provide links so I can read on this
  - muxator 5y ago
    The map() function is already lazy (in python 3 it returns a generator, and not a materialized list). You can also have a look at "generator expressions", which are the lazy counterpart to a list comprehension (hint: use " ()" instead of "[]").
  - dragonwriter 5y ago
    > Please provide links so I can read on this https://docs.python.org/3/library/functions.html#map https://docs.python.org/3/library/functions.html#map https://docs.python.org/3/library/functions.html#filter https://docs.python.org/3/library/functions.html#filter https://docs.python.org/3/howto/functional.html https://docs.python.org/3/howto/functional.html
deltaonefour 5y ago
Python syntax is very very well suited for functional programming. A python map and filter is done with list comprehensions and even flatmap is doable within the list comprehension ecosystem. Additionally the syntax transfers over to inputting values into n-arity functions and even dictionary comprehensions. Note that this feature Isn't even part of the python standard library... map and filter and flatmap are an inherit part of the CORE syntax. It makes it much better suited for FP then javascript imo. x = [i*2 for i in range(5)] #[0, 2, 4, 6, 8] y = [i for i in range(8) if i%2 == 0] #[0, 2, 4, 6, 8] z = [[1],[2],[3],[4]] w = [j for i in z for j in i] #[1,2,3,4] t = {str(j):j*2 for j in w} #{"1":1, "2":4, "3":6, "4":8} #reduce (note the generator (i for i in range(20))... that's a lazy list essentially) reduce(lambda acc, x: x + acc, (i for i in range(20)), 0) #sum(0 ... 20) #get max value from a bunch of numbers: f = max(i for i in range(30) if 30 % 3 == 0) #max(0, 3, 9, 12, 15, 18, 21, 24, 27, 30) = 30 #basic recursion def myreverse(x: str) -> str: return x if len(x) <= 1 else x[-1] + myreverse(x[:-1]) #O(N) on each slice, (However x[-1] is O(1) unlike the haskell list). #qsort haskell style def qsort(l: List[int]) -> List[int]: return l if len(l) <= 1 else qsort([i for i in l if i <= l[0]]) + qsort([i for i in l if i > l[0]]) Python also supports pattern matching shown here: https://www.python.org/dev/peps/pep-0636/ https://www.python.org/dev/peps/pep-0636/ Additionally lambda syntax, aka python anonymous first class functions HAVE to be functional. f = lambda x: x + 1 There is no procedural concepts like variable assignment allowed in a python lambda. This is done because they wanted to force the python lambda to be properly functional and short. The type hints that python uses are also quite good with support for generics sum types and even type level programming (however your type checker needs to support it too and basically none of them do right now) You can literally assign a type to a variable in python. See: https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html I would say the main weakness in python is that the IMPLEMENTATION is not well suited for functional programming (but the syntax VERY much is). Tail slices on lists like x[1:] cost O(N) and that's the biggest issue right now imo. It makes some valid solutions on leetcode exceed the time limit because it adds and additional N complexity on every slice when the head and tail functions in haskell cost O(1) I'm sure some library can easily provide the underlying functional primitives python needs to be faster. Actually on that note, does anyone know of a library that solves the head tail slicing problem I described above? Probably should use the python deque, but the api for that is inherently not functional.
ok_dad 5y ago
> ain’t very good with maps and filters Isn't a comprehension just a map/filter by another syntax? You can re-create them from a list comprehension pretty simply: `map = lambda data, map_fn : [map_fn(x) for x in data]` `filter = lambda data, filter_fn : [x for x in data if filter_fn(x)]` Then, why even have the lambda-translations above since the comprehension is already "Pythonic"? Also, you have functools (https://docs.python.org/3/library/functools.html https://docs.python.org/3/library/functools.html) which you can use for several functional programming paradigms as well. Functional programming isn't what you call the techniques (map/filter/etc.) it's how you are programming that makes it functional. You can still use functional techniques in Python to make things a bit easier to reason about. A lot of the things people thing about functional programming aren't inherent to the actual functional programming paradigm: like laziness or immutability.
- muxator 5y ago
  Nit: in py3 map() and filter() are lazy (they return iterators instead of lists). You can better mimic their semantics using generator expressions "()" instead of list comprehensions "[]".

dragonwriter 5y ago

> Why the one would write functional code in a language that ain’t very good with maps and filters, has no lazy calculations and has no constants on language design level? Python is fine with maps and filters, and has lazy calculations.

impoppy 5y ago
Please provide links so I can read on this
- muxator 5y ago
  The map() function is already lazy (in python 3 it returns a generator, and not a materialized list). You can also have a look at "generator expressions", which are the lazy counterpart to a list comprehension (hint: use " ()" instead of "[]").
- dragonwriter 5y ago
  > Please provide links so I can read on this https://docs.python.org/3/library/functions.html#map https://docs.python.org/3/library/functions.html#map https://docs.python.org/3/library/functions.html#filter https://docs.python.org/3/library/functions.html#filter https://docs.python.org/3/howto/functional.html https://docs.python.org/3/howto/functional.html

deltaonefour 5y ago

Python syntax is very very well suited for functional programming. A python map and filter is done with list comprehensions and even flatmap is doable within the list comprehension ecosystem. Additionally the syntax transfers over to inputting values into n-arity functions and even dictionary comprehensions. Note that this feature Isn't even part of the python standard library... map and filter and flatmap are an inherit part of the CORE syntax. It makes it much better suited for FP then javascript imo. x = [i*2 for i in range(5)] #[0, 2, 4, 6, 8] y = [i for i in range(8) if i%2 == 0] #[0, 2, 4, 6, 8] z = [[1],[2],[3],[4]] w = [j for i in z for j in i] #[1,2,3,4] t = {str(j):j*2 for j in w} #{"1":1, "2":4, "3":6, "4":8} #reduce (note the generator (i for i in range(20))... that's a lazy list essentially) reduce(lambda acc, x: x + acc, (i for i in range(20)), 0) #sum(0 ... 20) #get max value from a bunch of numbers: f = max(i for i in range(30) if 30 % 3 == 0) #max(0, 3, 9, 12, 15, 18, 21, 24, 27, 30) = 30 #basic recursion def myreverse(x: str) -> str: return x if len(x) <= 1 else x[-1] + myreverse(x[:-1]) #O(N) on each slice, (However x[-1] is O(1) unlike the haskell list). #qsort haskell style def qsort(l: List[int]) -> List[int]: return l if len(l) <= 1 else qsort([i for i in l if i <= l[0]]) + qsort([i for i in l if i > l[0]]) Python also supports pattern matching shown here: https://www.python.org/dev/peps/pep-0636/ https://www.python.org/dev/peps/pep-0636/ Additionally lambda syntax, aka python anonymous first class functions HAVE to be functional. f = lambda x: x + 1 There is no procedural concepts like variable assignment allowed in a python lambda. This is done because they wanted to force the python lambda to be properly functional and short. The type hints that python uses are also quite good with support for generics sum types and even type level programming (however your type checker needs to support it too and basically none of them do right now) You can literally assign a type to a variable in python. See: https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html I would say the main weakness in python is that the IMPLEMENTATION is not well suited for functional programming (but the syntax VERY much is). Tail slices on lists like x[1:] cost O(N) and that's the biggest issue right now imo. It makes some valid solutions on leetcode exceed the time limit because it adds and additional N complexity on every slice when the head and tail functions in haskell cost O(1) I'm sure some library can easily provide the underlying functional primitives python needs to be faster. Actually on that note, does anyone know of a library that solves the head tail slicing problem I described above? Probably should use the python deque, but the api for that is inherently not functional.

ok_dad 5y ago

> ain’t very good with maps and filters Isn't a comprehension just a map/filter by another syntax? You can re-create them from a list comprehension pretty simply: `map = lambda data, map_fn : [map_fn(x) for x in data]` `filter = lambda data, filter_fn : [x for x in data if filter_fn(x)]` Then, why even have the lambda-translations above since the comprehension is already "Pythonic"? Also, you have functools (https://docs.python.org/3/library/functools.html https://docs.python.org/3/library/functools.html) which you can use for several functional programming paradigms as well. Functional programming isn't what you call the techniques (map/filter/etc.) it's how you are programming that makes it functional. You can still use functional techniques in Python to make things a bit easier to reason about. A lot of the things people thing about functional programming aren't inherent to the actual functional programming paradigm: like laziness or immutability.

muxator 5y ago
Nit: in py3 map() and filter() are lazy (they return iterators instead of lists). You can better mimic their semantics using generator expressions "()" instead of list comprehensions "[]".