ðŸŽ‰ Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io ðŸŽ‰

# hyphenrf's solution

## to Bob in the Elm Track

Published at Jul 15 2020 · 0 comments
Instructions
Test suite
Solution

Bob is a lackadaisical teenager. In conversation, his responses are very limited.

Bob answers 'Sure.' if you ask him a question, such as "How are you?".

He answers 'Whoa, chill out!' if you YELL AT HIM (in all capitals).

He answers 'Calm down, I know what I'm doing!' if you yell a question at him.

He says 'Fine. Be that way!' if you address him without actually saying anything.

He answers 'Whatever.' to anything else.

Bob's conversational partner is a purist when it comes to written communication and always follows normal rules regarding sentence punctuation in English.

## Elm Installation

Refer to the Installing Elm page for information about installing elm.

## Writing the Code

The code you have to write is located inside the `src/` directory of the exercise. Elm automatically installs packages dependencies the first time you run the tests so we can start by running the tests from the exercise directory with:

``````\$ elm-test
``````

To automatically run tests again when you save changes:

``````\$ elm-test --watch
``````

As you work your way through the tests suite in the file `tests/Tests.elm`, be sure to remove the `skip <|` calls from each test until you get them all passing!

## Source

Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. http://pine.fm/LearnToProgram/?Chapter=06

## Submitting Incomplete Solutions

It is possible to submit an incomplete solution so you can see how others have completed the exercise.

### Tests.elm

``````module Tests exposing (anyCharacter, character, gibberish, gibberishQuestion, listOfCharacters, tests, uppercaseCharacter, uppercaseGibberish)

import Bob
import Char
import Expect
import Random
import String
import Test exposing (..)

tests : Test
tests =
describe "Bob"
[ test "stating something" <|
\() ->
Expect.equal "Whatever."
(Bob.hey "Tom-ay-to, tom-aaaah-to.")
, skip <|
test "shouting" <|
\() ->
Expect.equal
"Whoa, chill out!"
(Bob.hey "WATCH OUT!")
, skip <|
test "shouting gibberish" <|
\() ->
Expect.equal
"Whoa, chill out!"
(Bob.hey (uppercaseGibberish 10))
, skip <|
\() ->
Expect.equal
"Sure."
(Bob.hey "Does this cryogenic chamber make me look fat?")
, skip <|
test "asking a numeric question" <|
\() ->
Expect.equal
"Sure."
(Bob.hey "You are, what, like 15?")
, skip <|
\() ->
Expect.equal
"Sure."
(Bob.hey (gibberishQuestion 20))
, skip <|
test "talking forcefully" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "Let's go make out behind the gym!")
, skip <|
test "using acronyms in regular speech" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "It's OK if you don't want to go to the DMV.")
, skip <|
test "forceful questions" <|
\() ->
Expect.equal
"Calm down, I know what I'm doing!"
(Bob.hey "WHAT THE HELL WERE YOU THINKING?")
, skip <|
test "shouting numbers" <|
\() ->
Expect.equal
"Whoa, chill out!"
(Bob.hey "1, 2, 3 GO!")
, skip <|
test "only numbers" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "1, 2, 3")
, skip <|
test "question with only numbers" <|
\() ->
Expect.equal
"Sure."
(Bob.hey "4?")
, skip <|
test "shouting with special characters" <|
\() ->
Expect.equal
"Whoa, chill out!"
(Bob.hey "ZOMG THE %^*@#\$(*^ ZOMBIES ARE COMING!!11!!1!")
, skip <|
test "shouting with no exclamation mark" <|
\() ->
Expect.equal
"Whoa, chill out!"
(Bob.hey "I HATE YOU")
, skip <|
test "statement containing a question mark" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "Ending with ? means a question.")
, skip <|
test "prattling on" <|
\() ->
Expect.equal
"Sure."
(Bob.hey "Wait! Hang on. Are you going to be OK?")
, skip <|
test "silence" <|
\() ->
Expect.equal
"Fine. Be that way!"
(Bob.hey "")
, skip <|
test "prolonged silence" <|
\() ->
Expect.equal
"Fine. Be that way!"
(Bob.hey "       ")
, skip <|
test "alternate silences" <|
\() ->
Expect.equal
"Fine. Be that way!"
(Bob.hey "\t  \n  \t   ")
, skip <|
test "on multiple line questions" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "\nDoes this cryogenic chamber make me look fat?\nno")
, skip <|
test "ending with whitespace" <|
\() ->
Expect.equal
"Sure."
(Bob.hey "Okay if like my  spacebar  quite a bit?   ")
, skip <|
test "no letters" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "1, 2, 3")
, skip <|
test "question with no letters" <|
\() ->
Expect.equal
"Sure."
(Bob.hey "4?")
, skip <|
test "statement containing question mark" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "Ending with ? means a question.")
, skip <|
test "non-letters with question" <|
\() ->
Expect.equal
"Sure."
(Bob.hey ":) ?")
, skip <|
test "starting with whitespace" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "         hmmmmmmm...")
, skip <|
test "other whitespace" <|
\() ->
Expect.equal
"Fine. Be that way!"
(Bob.hey "\n\u{000D} \t")
, skip <|
test "non-question ending with whitespace" <|
\() ->
Expect.equal
"Whatever."
(Bob.hey "This is a statement ending with whitespace      ")
]

character : Int -> Int -> Random.Generator Char
character start end =
Random.map Char.fromCode (Random.int start end)

anyCharacter : Random.Generator Char
anyCharacter =
character 32 126

uppercaseCharacter : Random.Generator Char
uppercaseCharacter =
character 65 90

listOfCharacters : Int -> Random.Generator Char -> Random.Generator (List Char)
listOfCharacters length characterList =
Random.list length characterList

gibberish : Int -> Random.Generator Char -> String
gibberish length characterList =
Tuple.first (Random.step (Random.map String.fromList (listOfCharacters length characterList)) (Random.initialSeed 424242))

uppercaseGibberish : Int -> String
uppercaseGibberish length =
gibberish length uppercaseCharacter

gibberishQuestion : Int -> String
gibberishQuestion length =
gibberish length anyCharacter ++ "?"``````
``````module Bob exposing (hey)

hey : String -> String
hey remark =
case String.trim remark of
"" ->
"Fine. Be that way!"

cs ->
case ( isQuestion cs, notYelling cs ) of
( True, True ) ->
"Sure."

( True, False ) ->
"Calm down, I know what I'm doing!"

( False, True ) ->
"Whatever."

( False, False ) ->
"Whoa, chill out!"

isQuestion : String -> Bool
isQuestion =
String.endsWith "?"

notYelling : String -> Bool
notYelling string =
not (String.any Char.isUpper string)
|| String.any Char.isLower string``````