Haskell

Haskell, being a functional language and also just being Haskell, is syntaxically very different from most languages. So in order to get into the real juice I need to body you with some basic syntax explanation, just to make sure we are on the same page. Functions are the primary building block of Haskell. In fact, Haskell doesn't even feature variables. Everything is done using functions and arg The way Haskell oppresses the problem of dealing with external states or impure code is a very complicated topic w Functions in Haskell are defined in a way that is more They consist of a function name, the arg For example, a function that squares a notice how Haskell only uses spaces to separate the arg This syntactic decision is related to the concept of curring, which we will talk about later Calling a function is similar to defining one. We once again use spaces to separate the arg T If the arg Haskell actually allows you to call every binary function as an infix function by surrounding a function name with backticks. T Another key part of the Haskell language is the type system. Up until now, I only showed you half of the code that you should be writing when creating functions. Every function should be supplied with a type, which is written This would describe a function that takes two arg Notice how the return type of the function is not denoted separately from the arg T Don't worry, just a couple more t Promise. For example, the type of our square function we made earlier would do it Some functions work for more than one discrete type, like functions that operate on lists or n In order to deal with these will ass If two type variables have the same name however, they must always be the same type. A good example of t It takes a list of some type a, and returns the first element of that list, w T Okay, so let's use there's one problem however. When we try to change the integer types to type variables, we get a compiler error. This is because we are using the multiply operation, which only works for n But right now we are specifying our function except all types, not just n We need a way to restrict the type a can ass This is done with the n A type class is a description of what functionality a type must implement in order to derive from it. It is a lot This type, which reads function square has type a to a, where type a is an instance of n So what is t I'll have to disappoint you that it is in fact not related to curry, but it is still very neat. Basically, currying allows us to leave out some of the arg How does t Well, let's grab our magnitude function from earlier. In t So what happens when we don't provide the second arg Interestingly, we don't get a compiler error. T If you look at the type of magnitude again, it's like we have shaved off the first arg If we then provide another arg T So what if I want to create a branch in my code? Where are my if else statements? Haskell has three main methods for branc The first one is if then else blocks. An if then else block is more It takes a condition and evaluates through the first expression when it is true and the second expression when it is false. Haskell has no else if blocks, however. So when you need to check for multiple conditions, you'll have to use nested if statements or use one of the other methods for branc Pattern matching is a bit of syntactic sugar that allows us to control the flow of the function by matching over the arg For example, a function that returns one when the n Haskell will match the provided arg T Cool, but how do we solve the else if problem? Pattern matc This function will return the sign of a given n Each pipe symbol represents a case where on the left of the equal sign we have a condition and on the right the expression to evaluate. Otherwise it's It gets evaluated when all other guards fail to match. To finish off, let and where blocks are the simplest of them all. They allow us to split our functions into multiple parts or steps. Whether you use let or where is mostly based on preference, I prefer to use let in most cases, but you can use where if you want to. As most of the syntax covered, we are now ready to look at how Haskell uses these features to deal with common coding problems and how it is different from imperative languages. Up next is lists and recursions, so until then stay safe and have a good one.