An example of what I am talking about is takeWhile
takeWhile :: (a -> Bool) -> [a] -> [a]
Example usage
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
From what I can tell (< 3) becomes (a < 3) where a is the current item in the list being checked.
How is this done in Haskell and how would I be able to move where a goes so I could do something like
takeWhile ((length a) < 4) ["aaa", "aaaaa"]
(< 3) is called a "section" and works only with infix operators. It's a syntactic sugar to write abbreviated functions. (< 3) is equivalent to \x -> x < 3 and (3 <) is equivalent to \x -> 3 < x.
Thus, (< 3) is a function of one argument that returns a Bool. Which is exactly what takeWhile expects.
With length, you have to write a function in full:
takeWhile (\x -> length x < 4) ["aaa", "aaaaa"]
or define your own function you can curry:
shorterThan n x = length x < n
takeWhile (shorterThan 4) ["aaa", "aaaaa"]
If you are feeling adventurous, you can write
takeWhile ((< 4) . length) ["aaa", "aaaaa"]
or perhaps in a more readable fashion
(??) = flip (.)
takeWhile (length ?? (< 4)) ["aaa", "aaaaa"]
There go nowhere, you have to remember that every function in Haskell is currified, so, think in the (+) function, you can do the next, think in the type first:
(+) :: Num a => a -> a -> a
now I can do my custom plusOne, plusTwo, etc, so fast thanks to the curryfication, because
(+) :: Num a => a -> a -> a
has "implicit paranthesis" and really looks like:
(+) :: Num a => a -> (a -> a)
meaning give me a number a give you a function back, so:
plusOne :: Num a => a -> a
plusOne = (+1)
plusTwo :: Num a => a -> a
plusTwo = (+2)
Can you see? you transform the (+) in a new function by giving to it just one of the two parameters, same happens with < and > functions, you can create the function greaterThanTen like this:
greaterThanTen :: (Num a, Ord a) => a -> a
greaterThanTen = (>10)
So in your example of takeWhile (< 3) your (< 3) is the function "less than 3", and if you "read" all the function would be "take while n is less than 3"
you can play around with it in the console by asking the types with :t command
:t (< 3)
(< 3) :: (Num a, Ord a) => a -> Bool
The first argument to takeWhile is a predicate; this is your unary function (< 3), which is true, when the argument has numeric semantics and is less than 3. This option is applied to each list member, making up a new list and terminating, when the predicate is not true the first time. The elements, which have passed, make up the result list.
Your example is almost correct, you must only convert it into predicate form, i.e. create an unary function, which is true, when the parameter (a string) has a length less than 4. This can for example done by
(\a -> (length a) < 4)
then
takeWhile (\a -> (length a) < 4) ["aaa", "aaaaa"]
should do what you expect.