In Haskell String is an alias for [Char]:

type String = [Char]

If you just want a function that converts a single char to a string you could e.g. do

charToString :: Char -> String
charToString c = [c]

If you prefer pointfree style you could also write

charToString :: Char -> String
charToString = (:[])

++ works only for lists, but x and y are only Char. After all, they're elements from a String (= [Char]), whereas the LYAH example had lists of lists of Char: [String] = [[Char]]:

-- [a] -> [a] -> [a]
-- vv     vv
[y ++ ' ' ++ y | x <- "abd", y <- "bcd"]
--           ^   ^           ^
--           Char           Char

-- vs

--                                        [String]          [String]
--                                       vvvvvvvvvv          vvvvv
[adjective ++ " " ++ noun | adjective <- adjectives, noun <- nouns]  
-- ^^^^^^^           ^^^^
-- String           String

Instead, use (:) to cons the characters on each other and onto the empty list:

[x : ' ' : y : [] | x <- "abd", y <- "bcd"]

As you say ++ is the concat operator for lists. It takes a list, and adds another list to the end, for example, [1, 2, 3] ++ [4, 5, 6] == [1,2,3,4,5,6]. The issue in your case is you're attempting to add a character to a character - not a list to a list.

A string is a list of characters, so instead we could do:

map (\x -> [x] ++ ['A']) ['A'..'Z']

However, this is a bit cumbersome and ugly. If we just want to add one item to the start of a list, we can use the : operator. In this way, we can invert the problem. Instead of adding 'A' to the end of each character, we can add the character to the start of 'A'.

For example:

map (\x -> x : "A") ['A'..'Z']

We can then ETA reduce this to:

map (: "A") ['A'..'Z']

As you may notice, I have replaced 'A' with "A". "A" is a list of characters, which happens to be one element long. Now, we can add one character to the list, the input, instead of having to convert both to lists first.

And we can see, it works as expected:

Prelude> map (: "A") ['A'..'Z']
["AA","BA","CA","DA","EA","FA","GA","HA","IA","JA","KA","LA","MA","NA","OA","PA","QA","RA","SA","TA","UA","VA","WA","XA","YA","ZA"]

The magic of currying:

myF :: String -> String
myF = (++) "const"

or (as mentioned by @jamshidh)

myF :: String -> String
myF = ("const" ++)

Explanation

We say (++) is a function takes two arguments but really all functions in Haskell take only one argument. Lets look at the signature for the (++) function:

(++) :: String -> String -> String

We can describe (++) or "the concatenation" function as acting like so:

"Take one string and return a function that takes another string concatenates (joins together) the two strings and return that string"

So when we say myF = (++) "const" we are assigning the resulting function from applying the first string to (++) function to myF function. This is known as "Partial Application".

Notice we don't need to include an argument at the end of function like this but this is still perfectly fine:

myF arg = "const" ++ arg

We can leave out the "arg" because from the partially applied "concat" function we already know that we are expecting one more string argument.

combine = zipWith (++)

zipWith takes two lists, and applies the function given to the first item of both lists, then the second, etc. If one list is longer than the other, its extra items will be skipped.

The ++ function takes two lists and joins them together. A string is just a list of characters.

"hello " ++ "world" == "hello world"

usage:

λ> combine ["me","you","he"] ["she","they","it"]
["meshe","youthey","heit"]
λ> combine [] []
[]
λ> combine ["me", "you"] ["she"]
["meshe"]
λ> 

The ++ operator is very basic though, so you might be better continuing reading whatever learning material you're using before coming to stackoverflow, as you'll have a lot of questions which I expect will be answered in your book.

If you don't want to use zipWith, you can write it very simply with recursion like so:

combine [] _ = []
combine _ [] = []
combine (x:xs) (y:ys) = (x ++ y) : combine xs ys

Usage is the same as before.