Please enable JavaScript.

Coggle requires JavaScript to display documents.

4.12.1/2 Fundamentrals of functional programming & Funcctional…

- - - - f:integer x integer --> integer
      - domain == cartesian cross product
        
        single argument of a (x,y) tuple
        
        add a b == add a. + b
  - - - 1) Appear in an expression
      - 2) Be assigned to a variable
      - 3) be assigned to an argument
      - 4) Be a returned in a function call
    - - Integer
      - floating-point types
      - chars
      - String
  - - - g o f apply 2nd function f first
        apply f ot x and then apply g to the result
- - - - Haskell
      - c#
      - Python
      - Java8
    - - at least one of
        
        function accpted as an argument
        ! not same as composition!
        hof(SomeFunction) and not
        hof(SomeFunction())
        
        function is returned as a value
        ! not the same a evaluation
        return SomeFunction
        not return SomeFunction()
        
        both of the above
    - - map
        
        map(function, Collection) --> Collection
        python3:
        squared = list(map(lambda x: x*x, [1,2,3,4])
        c#:
        using System.Linq;
        //in main....
        int[] numbers = {1,2,3,4};
        var squared = number.Select(x => x * x);
        Java:
        import java.util.;
        import java.util.stream.;
        // in main...
        List<Integer> numbers = Array.asList(1,2,3,4);
        List<Integer> squared = numbers.stream()
        .map(x -> x*x)
        .toList();
      - filter
        
        filter(function, Collection) -> Collection
        python3:
        numbers = [1,2,3,4,5,6]
        evens = list(filter(lambda x: x % 2 ==0, numbers))
        c#
        using System;
        using System.Linq;
        //in main ..
        int[] numbers = {1,2,3,4,5,6};
        var even = numbers.Where(x => x % 2 == 0));
        Java:
        import java.util.;
        import java.util.stream.;
        //in main...
        List<Integer> numbers = Array.asList(1,2,3,4,5,6);
        List<Integer> even = numbers.stream()
        .filter(x -> x % 2 == 0)
        .toList();
      - reduce
        
        reduce(function, Collection) --> AggregateType
        python3:
        from functools import reduce
        numbers = [1,,2,3,4,5,6]
        total= reduce(lambda acc, x: acc + x, numbers)
        c#
        using System;
        using System.Linq;
        //in main...
        int[] numbers = {1,2,3,4,5,6};
        int total = numbers.Aggregate((acc,x)=>acc+x);
        Java:
        import java.util.;
        import java.util.stream.;
        //in main...
        List<Integer> numbers = Array.asList(1,2,3,4,5,6);
        int total = numbers.stream()
        .reduce(0,(acc,0)-> acc+x);