Ive been trying to create a recursive function that takes a list of integers and gets the sum of the square root. i've come from c# and im pretty new to haskell. I feel as though ive hit a comprehension block

i was having problems with types so i tried making an integer sqrt to help myself out, but ended up confusing myself more..

```
isqrt :: Integer -> Integer
isqrt = floor . sqrt . fromIntegral
sumsquares :: Int a => [a] -> a
sumsquares f [] = "List is Empty"
sumsquares f (x:xs) | sum . isqrt x | x <- xs
```

ive only done a little recursion and i can't find anywhere that really explains it in a way i understand

## How your code is uncompilable

```
sumsquares :: Int a => [a] -> a
```

The type signature is weird. `Int`

is a type but you are using with the class syntax. What you really meant ("a list of integers") was:

```
[Integer] -> Integer
```

You are also taking as an argument an `f`

that simply isn't there. This makes me think that you thought `Int a =>`

was an argument. It's not. Anything in the form `X a =>`

is a type class constraint that does not contribute to the arity of the function.

Then we have:

```
sumsquares f [] = "List is Empty"
```

This is unreasonable and incorrect. Generally speaking one would expect that the sum of an empty list is `0`

or `mempty`

(that's for a more complicated topic). `"List is Empty"`

is a `String`

(unless `OverloadedString`

is in place), so that line wouldn't even compile.

Finally:

```
sumsquares f (x:xs) | sum . isqrt x | x <- xs
```

I don't know what you were trying to do here, but `|`

is used for conditionals. For example:

```
sumSquares :: [Integer] -> Integer
sumSquares x
| null x = 0
| otherwise = (isqrt . head $ x) + tail x
```

## Solution with explicit recursion

That would be like this:

```
sumSquares :: [Integer] -> Integer
sumSquares [] = 0
sumSquares (x:xs) = isqrt x + sumSquares xs
```

## Solution with `map`

Using `map`

, it's simply:

```
sumSquares :: [Integer] -> Integer
sumSquares = sum . map isqrt
```