# How can I check if integers from one list are divisible integers from another?

I am trying to create a function that takes `Int`

( `n`

) and a list `k`

of `Int`

s and returns the sum of all numbers `1 <= i <= n`

that are divisible by at least one of the integers from the list `k`

.

```
addl::Int -> [Int] -> Int
addl x [] = 0
addl x (y:ys) = if ((map [1..x] `mod` y) == 0)
then y + addl x ys
else 0 + addl x ys
```

This is what I got, but I get this message:

```
Couldn't match expected type `a0 -> b0' with actual type `[t0]'
In the first argument of `map', namely `[1 .. x]'
In the first argument of `mod', namely `map [1 .. x]'
In the first argument of `(==)', namely `(map [1 .. x] `mod` y)'
```

which I tried to figure out but didn't figure it out yet. All help is greatly appreciated.

source to share

`map`

expects the function to be the first argument, but you supply a list to it.

The error message says the same. This means that the expression is `((map [1..x] `mod` y) == 0)`

parsed as

```
(==) -- In the first argument of `(==)', namely `(map [1 .. x] `mod` y)'
mod -- In the first argument of `mod', namely `map [1 .. x]'
map [1..x] -- In the first argument of `map', namely `[1 .. x]'
y
0
-- Couldn't match expected type `a0 -> b0' with actual type `[t0]'
```

`map`

A type

```
Prelude> :t map
map :: (a -> b) -> [a] -> [b]
Prelude> :t [undefined]
[undefined] :: [a]
```

and `(a1 -> b1)`

and `[a2]`

do not match.

Instead of mixing up the two actions (filtering and summing) in your code, vaguely (you even summarize the wrong variable `y`

there), it's easier to simplify the process for the first lookup, and only then, summing:

```
addl::Int -> [Int] -> Int
addl n ks = sum -- then, sum
[i | i <- [1..n], isDividedByAny i ks] -- first, search
where
isDividedByAny i ks =
any
[ rem i k == 0 | k <- ks]
```

Here we are using a built-in `any`

type function `(a -> Bool) -> [a] -> Bool`

(i.e. it takes a predicate function, a list of values and returns a boolean value).

Notice how I am calling your `k`

list `ks`

here to suggest the "k" list to him. This is idiomatic in Haskell.

source to share