GHCI -> GHCi

Author: Matthijs

source_md/functors-applicative-functors-and-monoids.md

@@ -223,7 +223,7 @@ So `a -> b -> c` can be written as `a -> (b -> c)`, to make the currying more ap
 In the same vein, if we write `fmap :: (a -> b) -> (f a -> f b)`, we can think of `fmap` not as a function that takes one function and a functor and returns a functor, but as a function that takes a function and returns a new function that's just like the old one, only it takes a functor as a parameter and returns a functor as the result.
 It takes an `a -> b` function and returns a function `f a -> f b`.
 This is called *lifting* a function.
-Let's play around with that idea by using GHCI's `:t` command:
+Let's play around with that idea by using GHCi's `:t` command:
 
 ```{.haskell:hs}
 ghci> :t fmap (*2)
@@ -241,7 +241,7 @@ When we say *a functor over numbers*, you can think of that as *a functor that h
 The former is a bit fancier and more technically correct, but the latter is usually easier to get.
 :::
 
-This is even more apparent if we partially apply, say, `fmap (++"!")` and then bind it to a name in GHCI.
+This is even more apparent if we partially apply, say, `fmap (++"!")` and then bind it to a name in GHCi.
 
 You can think of `fmap` as either a function that takes a function and a functor and then maps that function over the functor, or you can think of it as a function that takes a function and lifts that function so that it operates on functors.
 Both views are correct and in Haskell, equivalent.

source_md/higher-order-functions.md

@@ -130,7 +130,7 @@ From the definition of sections, `(-4)` would result in a function that takes a
 However, for convenience, `(-4)` means minus four.
 So if you want to make a function that subtracts 4 from the number it gets as a parameter, partially apply the `subtract` function like so: `(subtract 4)`.
 
-What happens if we try to just do `multThree 3 4` in GHCI instead of binding it to a name with a *let* or passing it to another function?
+What happens if we try to just do `multThree 3 4` in GHCi instead of binding it to a name with a *let* or passing it to another function?
 
 ```{.haskell:hs}
 ghci> multThree 3 4
@@ -140,9 +140,9 @@ ghci> multThree 3 4
     • In a stmt of an interactive GHCi command: print it
 ```
 
-GHCI is telling us that the expression produced a function of type `a -> a` but it doesn't know how to print it to the screen.
+GHCi is telling us that the expression produced a function of type `a -> a` but it doesn't know how to print it to the screen.
 Functions aren't instances of the `Show` typeclass, so we can't get a neat string representation of a function.
-When we do, say, `1 + 1` at the GHCI prompt, it first calculates that to `2` and then calls `show` on `2` to get a textual representation of that number.
+When we do, say, `1 + 1` at the GHCi prompt, it first calculates that to `2` and then calls `show` on `2` to get a textual representation of that number.
 And the textual representation of `2` is just the string `"2"`, which then gets printed to our screen.
 
 ## Some higher-orderism is in order {#higher-orderism}
@@ -392,7 +392,7 @@ First, we'll begin by mapping the `(^2)` function to the infinite list `[1..]`.
 Then we filter them so we only get the odd ones.
 And then, we'll take elements from that list while they are smaller than 10,000.
 Finally, we'll get the sum of that list.
-We don't even have to define a function for that, we can do it in one line in GHCI:
+We don't even have to define a function for that, we can do it in one line in GHCi:
 
 ```{.haskell:ghci}
 ghci> sum (takeWhile (<10000) (filter odd (map (^2) [1..])))

source_md/input-and-output.md

@@ -27,7 +27,7 @@ With those two parts separated, we can still reason about our pure program and t
 
 ![HELLO!](assets/images/input-and-output/helloworld.png){.left width=223 height=179}
 
-Up until now, we've always loaded our functions into GHCI to test them out and play with them.
+Up until now, we've always loaded our functions into GHCi to test them out and play with them.
 We've also explored the standard library functions that way.
 But now, after eight or so chapters, we're finally going to write our first *real* Haskell program!
 Yay!
@@ -208,14 +208,14 @@ We can also use a *do* block to glue together a few I/O actions and then we can
 Either way, they'll be performed only if they eventually fall into `main`.
 
 Oh, right, there's also one more case when I/O actions will be performed.
-When we type out an I/O action in GHCI and press return, it will be performed.
+When we type out an I/O action in GHCi and press return, it will be performed.
 
 ```{.haskell:hs}
 ghci> putStrLn "HEEY"
 HEEY
 ```
 
-Even when we just punch out a number or call a function in GHCI and press return, it will evaluate it (as much as it needs) and then call `show` on it and then it will print that string to the terminal using `putStrLn` implicitly.
+Even when we just punch out a number or call a function in GHCi and press return, it will evaluate it (as much as it needs) and then call `show` on it and then it will print that string to the terminal using `putStrLn` implicitly.
 
 Remember *let* bindings?
 If you don't, refresh your memory on them by reading [this section](syntax-in-functions.html#let-it-be).
@@ -429,8 +429,8 @@ True
 ```
 
 As you can see, it's a very handy function.
-Remember how we talked about how I/O actions are performed only when they fall into `main` or when we try to evaluate them in the GHCI prompt?
-When we type out a value (like `3` or `[1,2,3]`) and press the return key, GHCI actually uses `print` on that value to display it on our terminal!
+Remember how we talked about how I/O actions are performed only when they fall into `main` or when we try to evaluate them in the GHCi prompt?
+When we type out a value (like `3` or `[1,2,3]`) and press the return key, GHCi actually uses `print` on that value to display it on our terminal!
 
 ```{.haskell:hs}
 ghci> 3
@@ -534,9 +534,9 @@ ghci> sequence (map print [1,2,3,4,5])
 ```
 
 What's with the `[(),(),(),(),()]` at the end?
-Well, when we evaluate an I/O action in GHCI, it's performed and then its result is printed out, unless that result is `()`, in which case it's not printed out.
-That's why evaluating `putStrLn "hehe"` in GHCI just prints out `hehe` (because the contained result in `putStrLn "hehe"` is `()`).
-But when we do `getLine` in GHCI, the result of that I/O action is printed out, because `getLine` has a type of `IO String`.
+Well, when we evaluate an I/O action in GHCi, it's performed and then its result is printed out, unless that result is `()`, in which case it's not printed out.
+That's why evaluating `putStrLn "hehe"` in GHCi just prints out `hehe` (because the contained result in `putStrLn "hehe"` is `()`).
+But when we do `getLine` in GHCi, the result of that I/O action is printed out, because `getLine` has a type of `IO String`.
 
 Because mapping a function that returns an I/O action over a list and then sequencing it is so common, the utility functions `mapM`{.label .function} and `mapM_`{.label .function} were introduced.
 `mapM` takes a function and a list, maps the function over the list and then sequences it.
@@ -626,7 +626,7 @@ In this section, we learned the basics of input and output.
 We also found out what I/O actions are, how they enable us to do input and output and when they are actually performed.
 To reiterate, I/O actions are values much like any other value in Haskell.
 We can pass them as parameters to functions and functions can return I/O actions as results.
-What's special about them is that if they fall into the `main` function (or are the result in a GHCI line), they are performed.
+What's special about them is that if they fall into the `main` function (or are the result in a GHCi line), they are performed.
 And that's when they get to write stuff on your screen or play Yakety Sax through your speakers.
 Each I/O action can also encapsulate a result with which it tells you what it got from the real world.
 
@@ -1920,7 +1920,7 @@ This is cool because it won't cause the memory usage to skyrocket and the 32 KiB
 
 If you look through the [documentation](https://hackage.haskell.org/package/bytestring/docs/Data-ByteString-Lazy.html) for `Data.ByteString.Lazy`, you'll see that it has a lot of functions that have the same names as the ones from `Data.List`, only the type signatures have `ByteString` instead of `[a]` and `Word8` instead of `a` in them.
 The functions with the same names mostly act the same as the ones that work on lists.
-Because the names are the same, we're going to do a qualified import in a script and then load that script into GHCI to play with bytestrings.
+Because the names are the same, we're going to do a qualified import in a script and then load that script into GHCi to play with bytestrings.
 
 ```{.haskell:hs}
 import qualified Data.ByteString.Lazy as B

source_md/making-our-own-types-and-typeclasses.md

@@ -1418,7 +1418,7 @@ But this is just something to think about, because `==` will always have a type
 :::
 
 Ooh, one more thing, check this out!
-If you want to see what the instances of a typeclass are, just do `:info YourTypeClass` in GHCI.
+If you want to see what the instances of a typeclass are, just do `:info YourTypeClass` in GHCi.
 So typing `:info Num` will show which functions the typeclass defines and it will give you a list of the types in the typeclass.
 `:info` works for types and type constructors too.
 If you do `:info Maybe`, it will show you all the typeclasses that `Maybe` is an instance of.
@@ -1753,7 +1753,7 @@ A kind is more or less the type of a type.
 This may sound a bit weird and confusing, but it's actually a really cool concept.
 
 What are kinds and what are they good for?
-Well, let's examine the kind of a type by using the `:k` command in GHCI.
+Well, let's examine the kind of a type by using the `:k` command in GHCi.
 
 ```{.haskell:hs}
 ghci> :k Int
@@ -1902,7 +1902,7 @@ Well, we see it takes three type parameters, so it's going to be `something -> s
 It's safe to say that `p` is a concrete type and thus has a kind of `*`.
 For `k`, we assume `*` and so by extension, `t` has a kind of `* -> *`.
 Now let's just replace those kinds with the *somethings* that we used as placeholders and we see it has a kind of `(* -> *) -> * -> * -> *`.
-Let's check that with GHCI.
+Let's check that with GHCi.
 
 ```{.haskell:hs}
 ghci> :k Barry

source_md/modules.md

@@ -37,14 +37,14 @@ When you do `import Data.List`, all the functions that `Data.List` exports becom
 `nub` is a function defined in `Data.List` that takes a list and weeds out duplicate elements.
 Composing `length` and `nub` by doing `length . nub` produces a function that's the equivalent of `\xs -> length (nub xs)`.
 
-You can also put the functions of modules into the global namespace when using GHCI.
-If you're in GHCI and you want to be able to call the functions exported by `Data.List`, do this:
+You can also put the functions of modules into the global namespace when using GHCi.
+If you're in GHCi and you want to be able to call the functions exported by `Data.List`, do this:
 
 ```{.haskell:ghci}
 ghci> :m + Data.List
 ```
 
-If we want to load up the names from several modules inside GHCI, we don't have to do `:m +` several times, we can just load up several modules at once.
+If we want to load up the names from several modules inside GHCi, we don't have to do `:m +` several times, we can just load up several modules at once.
 
 ```{.haskell:ghci}
 ghci> :m + Data.List Data.Map Data.Set
@@ -945,7 +945,7 @@ Because `Data.Map` exports functions that clash with the `Prelude` and `Data.Lis
 import qualified Data.Map as Map
 ```
 
-Put this import statement into a script and then load the script via GHCI.
+Put this import statement into a script and then load the script via GHCi.
 
 Let's go ahead and see what `Data.Map` has in store for us!
 Here's the basic rundown of its functions.
@@ -1158,7 +1158,7 @@ Put this import statement in a script:
 import qualified Data.Set as Set
 ```
 
-And then load the script via GHCI.
+And then load the script via GHCi.
 
 Let's say we have two pieces of text.
 We want to find out which characters were used in both of them.

source_md/starting-out.md

@@ -17,7 +17,7 @@ GHCi, version 9.2.4: https://www.haskell.org/ghc/  :? for help
 ghci>
 ```
 
-Congratulations, you're in GHCI!
+Congratulations, you're in GHCi!
 
 Here's some simple arithmetic.
 
@@ -50,7 +50,7 @@ Pretty cool, huh?
 Yeah, I know it's not but bear with me.
 A little pitfall to watch out for here is negating numbers.
 If we want to have a negative number, it's always best to surround it with parentheses.
-Doing `5 * -3` will make GHCI yell at you but doing `5 * (-3)` will work just fine.
+Doing `5 * -3` will make GHCi yell at you but doing `5 * (-3)` will work just fine.
 
 Boolean algebra is also pretty straightforward.
 As you probably know, `&&` means a boolean *and*, `||` means a boolean *or*.
@@ -96,10 +96,10 @@ Well, if we try the first snippet, we get a big scary error message!
 ```
 
 Yikes!
-What GHCI is telling us here is that `"llama"` is not a number and so it doesn't know how to add it to 5.
+What GHCi is telling us here is that `"llama"` is not a number and so it doesn't know how to add it to 5.
 Even if it wasn't `"llama"` but `"four"` or `"4"`, Haskell still wouldn't consider it to be a number.
 `+` expects its left and right side to be numbers.
-If we tried to do `True == 5`, GHCI would tell us that the types don't match.
+If we tried to do `True == 5`, GHCi would tell us that the types don't match.
 Whereas `+` works only on things that are considered numbers, `==` works on any two things that can be compared.
 But the catch is that they both have to be the same type of thing.
 You can't compare apples and oranges.
@@ -189,7 +189,7 @@ The function name is followed by parameters separated by spaces.
 But when defining functions, there's a `=` and after that we define what the function does.
 Save this as `baby.hs` or something.
 Now navigate to where it's saved and run `ghci` from there.
-Once inside GHCI, do `:l baby`.
+Once inside GHCi, do `:l baby`.
 Now that our script is loaded, we can play with the function that we defined.
 
 ```{.haskell: .ghci}
@@ -211,7 +211,7 @@ doubleUs x y = x*2 + y*2
 
 Simple.
 We could have also defined it as `doubleUs x y = x + x + y + y`.
-Testing it out produces pretty predictable results (remember to append this function to the `baby.hs` file, save it and then do `:l baby` inside GHCI).
+Testing it out produces pretty predictable results (remember to append this function to the `baby.hs` file, save it and then do `:l baby` inside GHCi).
 
 ```{.haskell: .ghci}
 ghci> doubleUs 4 9
@@ -761,7 +761,7 @@ ghci> [ [ x | x <- xs, even x ] | xs <- xxs]
 ```
 
 You can write list comprehensions across several lines.
-So if you're not in GHCI, it's better to split longer list comprehensions across multiple lines, especially if they're nested.
+So if you're not in GHCi, it's better to split longer list comprehensions across multiple lines, especially if they're nested.
 
 ## Tuples {#tuples}
 
@@ -882,7 +882,7 @@ ghci> triangles = [ (a,b,c) | c <- [1..10], b <- [1..10], a <- [1..10] ]
 ```
 
 We're just drawing from three lists and our output function is combining them into a triple.
-If you evaluate that by typing out `triangles` in GHCI, you'll get a list of all possible triangles with sides under or equal to 10.
+If you evaluate that by typing out `triangles` in GHCi, you'll get a list of all possible triangles with sides under or equal to 10.
 Next, we'll add a condition that they all have to be right triangles.
 We'll also modify this function by taking into consideration that side b isn't larger than the hypotenuse and that side a isn't larger than side b.
 

source_md/types-and-typeclasses.md

@@ -23,7 +23,7 @@ A type is a kind of label that every expression has.
 It tells us in which category of things that expression fits.
 The expression `True` is a boolean, `"hello"` is a string, etc.
 
-Now we'll use GHCI to examine the types of some expressions.
+Now we'll use GHCi to examine the types of some expressions.
 We'll do that by using the `:t` command which, followed by any valid expression, tells us its type.
 Let's give it a whirl.
 
@@ -303,9 +303,9 @@ ghci> read "4"
     Probable fix: add a type signature that fixes these type variable(s)
 ```
 
-What GHCI is telling us here is that it doesn't know what we want in return.
+What GHCi is telling us here is that it doesn't know what we want in return.
 Notice that in the previous uses of `read` we did something with the result afterwards.
-That way, GHCI could infer what kind of result we wanted out of our `read`.
+That way, GHCi could infer what kind of result we wanted out of our `read`.
 If we used it as a boolean, it knew it had to return a `Bool`.
 But now, it knows we want some type that is part of the `Read` class, it just doesn't know which one.
 Let's take a look at the type signature of `read`.
@@ -338,7 +338,7 @@ ghci> read "(3, 'a')" :: (Int, Char)
 Most expressions are such that the compiler can infer what their type is by itself.
 But sometimes, the compiler doesn't know whether to return a value of type `Int` or `Float` for an expression like `read "5"`.
 To see what the type is, Haskell would have to actually evaluate `read "5"`.
-But since Haskell is a statically typed language, it has to know all the types before the code is compiled (or in the case of GHCI, evaluated).
+But since Haskell is a statically typed language, it has to know all the types before the code is compiled (or in the case of GHCi, evaluated).
 So we have to tell Haskell: "Hey, this expression should have this type, in case you don't know!".
 
 `Enum`{.label .class} members are sequentially ordered types --- they can be enumerated.