x => y => x * y

x -> y -> x * y

[](double x){return [x](double y){return x * y;};}

\x -> \y -> x * y

Another answer for Haskell is the three characters (*). Also, it was pretty common in C++ for people to forget the capture and the return keywords

1. You cannot write these in Haskell because there is no way to type the functions! For list to tuples, the input would have type List a but we can’t pick a a unique result type, since (a,a), (a,a,a,a,a,a), etc. are all different types—and Haskell does not have overloading. For tuples to lists, same reason, except we know the output type but cannot assign a unique input type.

2. toList3 :: (a,a,a) -> [a]
   toList3 (x, y, z) = [x, y, z]
   

function zip3({x, y, z}, [a, b, c]) {
  return [[x, a], [y, b], [z, c]];
}

Very important to pattern match both the object and the array. Pattern matching was the only acceptable answer here. Arrow functions were a nice try, but no.

To simulate default parameters in Java, use overloading.

1. The JavaScript type "string"? Yes_________ No, but it's a member of ___Null_______
2. The Python type str? Yes_________ No, but it's a member of ______NoneType______
3. The Java type String? Yes__X_______ No, but it's a member of __________________________
4. The C++ type string? Yes_________ No, but it's a member of ______string*___
5. The Haskell type [Char]? Yes_________ No, but it's a member of ____Maybe [Char]______

1. a = d; --okay, a dog is an animal
   ap = &d; -- okay, an animal pointer can point to a dog
   d = a; -- NO! a might be a different animal than a dog
   dp = &a --NO! a might be a different animal than a dog
   dp = (Dog*)(&a); --okay, you can cast explicitly, but beware
   dp = (Dog*)cp; --okay, again, explicit cast are accepted by the compiler
   ap = new Dog; --okay, an animal pointer can point to a dog
   ap = &(new Cat) --NO! cannot take the address of an r-value
   d = Dog(a) --NO! You cannot cast objects, only pointers.
2. No! Because animals.push_back(new Cat()) is and must always be allowed. So if we did allow animals = dogs then the compiler could not stop us from adding a cat to a list of dogs!

findIndex (all (==0)) a

IntStream.range(0, a.length)
    .filter(i -> Arrays.stream(a[i]).allMatch(x->x==0))
    .findFirst()

function c(n) {
  return n <= 1 ? 0 : 1 + c(n % 2 == 0 ? n / 2 : 3 * n + 1);
}

def c(n):
    return 0 if n <= 1 else 1 + c(n // 2 if n % 2 == 0 else 3 * n + 1)

int c(int n) {
  return n <= 1 ? 0 : 1 + c(n % 2 == 0 ? n / 2 : 3 * n + 1);
}

c n | n <= 1 = 0 | otherwise = 1 + c (if even n then n `div` 2 else 3 * n + 1)

def inorder(self):
    return []

def inorder(self):
    return self.left.inorder() + [self.data] + self.right.inorder()

In Haskell you write the function on the top-level:

inorder :: BinaryTree a -> [a]
inorder Empty = []
inorder (Node data left right) = inorder left ++ [data] ++ inorder right

1. You can’t move an L-value because an L-value is something that can be used later, and a move wipes out objects (leaves them all empty). R-values, OTOH, can not be used later so there is no problem pilfering their resources.
2. Moves exist because they are sooooooo efficient! They save the trouble of making multiple unncessary copies of possibly large objects. No copies are needed: just a few pointer moves is all it takes to do a move.