trackler 2.0.6.11 → 2.0.6.12

data/tracks/fsharp/exercises/alphametics/AlphameticsTest.fs

@@ -5,34 +5,54 @@ open NUnit.Framework
 open Alphametics
 
 [<Test>]
-let ``Can solve short puzzles`` () =
+let ``Puzzle with three letters`` () =
     let actual = solve "I + BB == ILL"
     let expected = ['I', 1; 'B', 9; 'L', 0] |> Map.ofList |> Some
     Assert.That(actual, Is.EqualTo(expected))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``Can solve long puzzles`` () =
-    let actual = solve "SEND + MORE == MONEY"
-    let expected = ['S', 9; 'E', 5; 'N', 6; 'D', 7; 'M', 1; 'O', 0; 'R', 8; 'Y', 2] |> Map.ofList |> Some
+let ``Solution must have unique value for each letter`` () =
+    let actual = solve "A == B"
+    Assert.That(actual, Is.EqualTo(None))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Leading zero solution is invalid`` () =
+    let actual = solve "ACA + DD == BD"        
+    Assert.That(actual, Is.EqualTo(None))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Puzzle with four letters`` () =
+    let actual = solve "AS + A == MOM"
+    let expected = ['A', 9; 'S', 2; 'M', 1; 'O', 0] |> Map.ofList |> Some
     Assert.That(actual, Is.EqualTo(expected))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``Can solve puzzles with multiplication`` () =
-    let actual = solve "IF * DR == DORI"
-    let expected = ['I', 8; 'F', 2; 'D', 3; 'R', 9; 'O', 1] |> Map.ofList |> Some
+let ``Puzzle with six letters`` () =
+    let actual = solve "NO + NO + TOO == LATE"
+    let expected = ['N', 7; 'O', 4; 'T', 9; 'L', 1; 'A', 0; 'E', 2] |> Map.ofList |> Some
     Assert.That(actual, Is.EqualTo(expected))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``Can solve puzzles with any boolean expression`` () =
-    let actual = solve "PI * R ^ 2 == AREA"
-    let expected = ['P', 9; 'I', 6; 'R', 7; 'A', 4; 'E', 0] |> Map.ofList |> Some
+let ``Puzzle with seven letters`` () =
+    let actual = solve "HE + SEES + THE == LIGHT"
+    let expected = ['E', 4; 'G', 2; 'H', 5; 'I', 0; 'L', 1; 'S', 9; 'T', 7] |> Map.ofList |> Some
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Puzzle with eight letters`` () =
+    let actual = solve "SEND + MORE == MONEY"
+    let expected = ['S', 9; 'E', 5; 'N', 6; 'D', 7; 'M', 1; 'O', 0; 'R', 8; 'Y', 2] |> Map.ofList |> Some
     Assert.That(actual, Is.EqualTo(expected))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``Cannot solve unsolvable puzzles`` () =
-    let actual = solve "A * B == A + B"
-    Assert.That(actual, Is.EqualTo(None))
+let ``Puzzle with ten letters`` () =
+    let actual = solve "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
+    let expected = ['A', 5; 'D', 3; 'E', 4; 'F', 7; 'G', 8; 'N', 0; 'O', 2; 'R', 1; 'S', 6; 'T', 9] |> Map.ofList |> Some
+    Assert.That(actual, Is.EqualTo(expected))

data/tracks/fsharp/exercises/alphametics/Example.fs

@@ -1,60 +1,25 @@
 module Alphametics
 
 open System
-open System.Text.RegularExpressions
-
-type Operators = Plus | Mult | Pow | Eq
-    
-type Token =
-    | Operand of int
-    | Operator of Operators
-
-let (|Int|_|) str =
-   match Int32.TryParse(str) with
-   | (true, i) -> Some i
-   | _ -> None
-
-let token (str: string) =
-    match str with
-    | "+"   -> Operator Plus
-    | "*"   -> Operator Mult
-    | "^"   -> Operator Pow
-    | "=="  -> Operator Eq
-    | Int i -> Operand i
-    | _     -> failwith "Invalid token"
 
-let breakBy item list =
-    match List.tryFindIndex (fun x -> x = item) list with
-    | None -> None
-    | Some i -> Some (list.[0..i - 1], list.[i + 1..])
-    
-let tokenize (str: string) = 
-    str.Split() 
-    |> List.ofArray
-    |> List.map token
-    |> breakBy (Operator Eq) 
-
-let operators = 
-    [(Pow,  fun x y -> pown x y |> Operand); 
-     (Mult, fun x y -> x * y |> Operand); 
-     (Plus, fun x y -> x + y |> Operand)]
-
-let rec simplifyOperator (operator, op) acc remainder =     
-    match remainder with    
-    | Operand x::Operator y::Operand z::xs when y = operator -> simplifyOperator (operator, op) (op x z::acc) xs
-    | x::xs -> simplifyOperator (operator, op) (x::acc) xs
-    | [] -> acc |> List.rev
+open FParsec
+open System.Text.RegularExpressions
 
-let simplify equation = operators |> List.fold (fun acc operator -> simplifyOperator operator [] acc) equation
+let plus = pstring " + "
+let equal = pstring " == "
+let operand = many1Satisfy isAsciiUpper
+let expression = sepBy operand plus
+let equation = expression .>> equal .>>. expression
 
-let solveEquation (left, right) = simplify left = simplify right
+let parseToOption parser (input: string) =
+    match run parser input with
+    | Success(result, _, _)   -> Some result
+    | Failure(errorMsg, _, _) -> None
 
-let equationIsCorrect input = 
-    match tokenize input with    
-    | None -> false
-    | Some equation -> solveEquation equation
+let parseEquation = parseToOption equation
 
-let chars (str: string) = str |> Seq.filter (Char.IsLetter) |> Set.ofSeq
+let operandToInt (map: Map<char, int>) (operand: string) =
+    Seq.fold (fun acc x -> acc * 10 + Map.find x map) 0 operand
 
 let generateCombinations length =
     let rec helper remaining options =
@@ -65,23 +30,23 @@ let generateCombinations length =
 
     helper length ([0..9] |> Set.ofList)
 
-let generateMaps (str: string) =
-    let c = chars str
-    let nonZeroChars = 
-        Regex.Matches (str, "([A-Z])[A-Z]*") 
-        |> Seq.cast<Match> 
-        |> Seq.map (fun m -> m.Groups |> Seq.cast<Group> |> Seq.map (fun n -> n.Value.Chars 0) |> Seq.item 1) 
-        |> Set.ofSeq
+let generateMaps (leftOperands, rightOperands) =
+    let operands = leftOperands @ rightOperands 
+    let chars = operands |> String.concat "" |> Set.ofSeq
+    let nonZeroChars = operands |> List.map Seq.head |> Set.ofList
    
-    generateCombinations (Set.count c)
-    |> Seq.map (Seq.zip c >> Map.ofSeq)
+    generateCombinations (Set.count chars)
+    |> Seq.map (Seq.zip chars >> Map.ofSeq)
     |> Seq.filter (fun m -> Set.forall (fun x -> Map.find x m <> 0) nonZeroChars)
 
-let trySolve (input: string) map =
-    map
-    |> Map.fold (fun (acc: string) (key: char) (value: int) -> acc.Replace(string key, string value)) input 
-    |> equationIsCorrect
+let sumOperands lettersToDigits = List.sumBy (operandToInt lettersToDigits)
+
+let trySolve (leftOperands, rightOperands) lettersToDigits =
+    let left = sumOperands lettersToDigits leftOperands
+    let right = sumOperands lettersToDigits rightOperands
+    left = right
 
 let solve input = 
-    generateMaps input
-    |> Seq.tryFind (trySolve input)
+    match parseEquation input with
+    | Some equation -> Seq.tryFind (trySolve equation) (generateMaps equation)
+    | None -> None

data/tracks/fsharp/exercises/binary-search-tree/BinarySearchTreeTest.fs

@@ -6,40 +6,40 @@ open BinarySearchTree
 [<Test>]
 let ``Data is retained`` () =
     let tree = singleton 4
-    Assert.That(tree |> value, Is.EqualTo(4))
+    Assert.That(tree |> value, Is.EqualTo(Some 4))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Inserting less`` () =
     let tree = singleton 4 |> insert 2
-    Assert.That(tree |> value, Is.EqualTo(4))
-    Assert.That(tree |> left |> Option.map value, Is.EqualTo(Some 2))
+    Assert.That(tree |> value, Is.EqualTo(Some 4))
+    Assert.That(tree |> left |> Option.bind value, Is.EqualTo(Some 2))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Inserting same`` () =
     let tree = singleton 4 |> insert 4
-    Assert.That(tree |> value, Is.EqualTo(4))
-    Assert.That(tree |> left |> Option.map value, Is.EqualTo(Some 4))
+    Assert.That(tree |> value, Is.EqualTo(Some 4))
+    Assert.That(tree |> left |> Option.bind value, Is.EqualTo(Some 4))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Inserting greater`` () =
     let tree = singleton 4 |> insert 5
-    Assert.That(tree |> value, Is.EqualTo(4))
-    Assert.That(tree |> right |> Option.map value, Is.EqualTo(Some 5))
+    Assert.That(tree |> value, Is.EqualTo(Some 4))
+    Assert.That(tree |> right |> Option.bind value, Is.EqualTo(Some 5))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Complex tree`` () =
     let tree = fromList [4; 2; 6; 1; 3; 7; 5]
-    Assert.That(tree |> value, Is.EqualTo(4))
-    Assert.That(tree |> left |> Option.map value, Is.EqualTo(Some 2))
-    Assert.That(tree |> left |> Option.bind (fun x -> x |> left) |> Option.map value, Is.EqualTo(Some 1))
-    Assert.That(tree |> left |> Option.bind (fun x -> x |> right) |> Option.map value, Is.EqualTo(Some 3))
-    Assert.That(tree |> right |> Option.map value, Is.EqualTo(Some 6))
-    Assert.That(tree |> right |> Option.bind (fun x -> x |> left) |> Option.map value, Is.EqualTo(Some 5))
-    Assert.That(tree |> right |> Option.bind (fun x -> x |> right) |> Option.map value, Is.EqualTo(Some 7))
+    Assert.That(tree |> value, Is.EqualTo(Some 4))
+    Assert.That(tree |> left |> Option.bind value, Is.EqualTo(Some 2))
+    Assert.That(tree |> left |> Option.bind (fun x -> x |> left) |> Option.bind value, Is.EqualTo(Some 1))
+    Assert.That(tree |> left |> Option.bind (fun x -> x |> right) |> Option.bind value, Is.EqualTo(Some 3))
+    Assert.That(tree |> right |> Option.bind value, Is.EqualTo(Some 6))
+    Assert.That(tree |> right |> Option.bind (fun x -> x |> left) |> Option.bind value, Is.EqualTo(Some 5))
+    Assert.That(tree |> right |> Option.bind (fun x -> x |> right) |> Option.bind value, Is.EqualTo(Some 7))
 
 [<Test>]
 [<Ignore("Remove to run test")>]

data/tracks/fsharp/exercises/binary-search-tree/Example.fs

@@ -2,30 +2,33 @@
 
 type Node = { left: Node option; value: int; right: Node option }
 
-let left node = node.left
+let left node  = node.left
 let right node = node.right
-let value node = node.value
+let value node = Some node.value
 
 let singleton value = { left = None; right = None; value = value }
 
 let rec insert newValue (tree: Node) =
-    let loop newValue node = 
-        match node with
-        | Some tree -> Some (insert newValue tree)
-        | None -> Some (singleton newValue)
+    let loop newValue = 
+        function
+        | Some x -> Some <| insert newValue x
+        | None   -> Some <| singleton newValue
 
-    if newValue <= tree.value then { tree with left = loop newValue tree.left }
-    else { tree with right = loop newValue tree.right }
+    match newValue with
+    | x when x <= tree.value -> 
+        { tree with left  = loop newValue tree.left }
+    | _ -> 
+        { tree with right = loop newValue tree.right }
 
 let toList tree = 
-    let rec loop x = 
-        match x with
+    let rec loop = 
+        function
         | Some node -> loop node.left @ [node.value] @ loop node.right
         | None -> []
 
-    loop (Some tree)
+    loop <| Some tree
 
-let fromList list = 
-    match list with
+let fromList = 
+    function
     | []    -> failwith "Cannot create tree from empty list."
-    | x::xs -> List.fold (fun acc elem -> insert elem acc) (singleton x) xs
+    | x::xs -> List.fold (fun acc elem -> insert elem acc) (singleton x) xs

data/tracks/fsharp/exercises/triangle/TriangleTest.fs

@@ -68,11 +68,6 @@ let ``Triangles with negative sides are illegal`` () =
 let ``Triangles violating triangle inequality are illegal`` () =
     Assert.That((fun () -> kind 1m 1m 3m |> ignore), Throws.InvalidOperationException)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
-let ``Triangles violating triangle inequality are illegal 2`` () =
-    Assert.That((fun () -> kind 2m 4m 2m |> ignore), Throws.InvalidOperationException)
-
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Triangles violating triangle inequality are illegal 3`` () =

data/tracks/go/README.md

@@ -28,8 +28,8 @@ This is because this repo only imports from the standard library and isn't expec
 
 ## Contributing Guide
 
-Please be familiar with the [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data)
-in the x-api repository.  This describes how all the language tracks are put together, as well as details about
+Please be familiar with the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md)
+in the x-common repository.  This describes how all the language tracks are put together, as well as details about
 the common metadata, and high-level information about contributing to existing problems and adding new problems.
 
 ## Problem Versioning
@@ -89,7 +89,7 @@ See `leap/example_gen.go` for an example of how this can be done.
 
 Whenever the shared JSON data changes, the test cases will need to be regenerated. To do this, make sure that the
 x-common repository has been cloned in the same parent-directory as the xgo repository. Then `cd` to the `xgo`
-directory and run `go run <problem>/example_gen.go`.
+directory and run `go run exercises/<problem>/example_gen.go`.
 
 You should see that the `<problem>/test_cases.go` file has changed. Commit the change.
 

data/tracks/go/config.json

@@ -51,18 +51,25 @@
       "topics": [
         "Time",
         "Mathematics",
-        "Text formatting"
+        "Text formatting",
+        "Equality"
       ]
     },
     {
       "difficulty": 1,
       "slug": "gigasecond",
-      "topics": []
+      "topics": [
+        "Time"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "hamming",
-      "topics": []
+      "topics": [
+        "Control-flow (loops)",
+        "Equality",
+        "Strings"
+      ]
     },
     {
       "difficulty": 1,

data/tracks/go/exercises/acronym/acronym.go

@@ -0,0 +1,5 @@
+package acronym
+
+const testVersion = 2
+
+func Abbreviate(string) string

data/tracks/go/exercises/bob/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("bob.json", &j, t); err != nil {
+	if err := gen.Gen("bob", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/clock/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("clock.json", &j, t); err != nil {
+	if err := gen.Gen("clock", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/connect/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("connect.json", &j, t); err != nil {
+	if err := gen.Gen("connect", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/custom-set/example_gen.go

@@ -20,7 +20,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("custom-set.json", &j, t); err != nil {
+	if err := gen.Gen("custom-set", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/gigasecond/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("gigasecond.json", &j, t); err != nil {
+	if err := gen.Gen("gigasecond", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/hamming/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("hamming.json", &j, t); err != nil {
+	if err := gen.Gen("hamming", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/largest-series-product/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("largest-series-product.json", &j, t); err != nil {
+	if err := gen.Gen("largest-series-product", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/leap/cases_test.go

@@ -1,17 +1,15 @@
 package leap
 
 // Source: exercism/x-common
-// Commit: 945d08e Merge pull request #50 from soniakeys/master
+// Commit: be6fa53 leap: Rewrite the test cases and their descriptions
 
 var testCases = []struct {
 	year        int
 	expected    bool
 	description string
 }{
-	{1996, true, "leap year"},
-	{1997, false, "non-leap year"},
-	{1998, false, "non-leap even year"},
-	{1900, false, "century"},
-	{2400, true, "fourth century"},
-	{2000, true, "Y2K"},
+	{2015, false, "year not divisible by 4: common year"},
+	{2016, true, "year divisible by 4, not divisible by 100: leap year"},
+	{2100, false, "year divisible by 100, not divisible by 400: common year"},
+	{2000, true, "year divisible by 400: leap year"},
 }

data/tracks/go/exercises/leap/example.go

@@ -1,6 +1,6 @@
 package leap
 
-const testVersion = 2
+const testVersion = 3
 
 func IsLeapYear(i int) bool {
 	return i%4 == 0 && i%100 != 0 || i%400 == 0

data/tracks/go/exercises/leap/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("leap.json", &j, t); err != nil {
+	if err := gen.Gen("leap", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/leap/leap.go

@@ -4,7 +4,7 @@
 package leap
 
 // testVersion should match the targetTestVersion in the test file.
-const testVersion = 2
+const testVersion = 3
 
 // It's good style to write a comment here documenting IsLeapYear.
 func IsLeapYear(int) bool {

data/tracks/go/exercises/leap/leap_test.go

@@ -7,7 +7,7 @@ import "testing"
 // Also define a testVersion with a value that matches
 // the targetTestVersion here.
 
-const targetTestVersion = 2
+const targetTestVersion = 3
 
 func TestLeapYears(t *testing.T) {
 	if testVersion != targetTestVersion {

data/tracks/go/exercises/meetup/example_gen.go

@@ -17,7 +17,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("meetup.json", &j, t); err != nil {
+	if err := gen.Gen("meetup", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/nucleotide-count/nucleotide_count_test.go

@@ -95,14 +95,9 @@ func TestSequenceHistograms(t *testing.T) {
 }
 
 func BenchmarkSequenceHistograms(b *testing.B) {
-	b.StopTimer()
 	for _, tt := range histogramTests {
 		for i := 0; i < b.N; i++ {
-			b.StartTimer()
-
 			tt.strand.Counts()
-
-			b.StopTimer()
 		}
 	}
 }

data/tracks/go/exercises/pangram/pangram.go

@@ -0,0 +1,5 @@
+package pangram
+
+const testVersion = 1
+
+func IsPangram(string) bool

data/tracks/go/exercises/raindrops/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("raindrops.json", &j, t); err != nil {
+	if err := gen.Gen("raindrops", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/rna-transcription/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("rna-transcription.json", &j, t); err != nil {
+	if err := gen.Gen("rna-transcription", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/roman-numerals/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("roman-numerals.json", &j, t); err != nil {
+	if err := gen.Gen("roman-numerals", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/exercises/word-count/example_gen.go

@@ -15,7 +15,7 @@ func main() {
 		log.Fatal(err)
 	}
 	var j js
-	if err := gen.Gen("word-count.json", &j, t); err != nil {
+	if err := gen.Gen("word-count", &j, t); err != nil {
 		log.Fatal(err)
 	}
 }

data/tracks/go/gen/gen.go

@@ -44,10 +44,11 @@ func init() {
 	}
 }
 
-func Gen(jFile string, j interface{}, t *template.Template) error {
+func Gen(exercise string, j interface{}, t *template.Template) error {
 	if dirMetadata == "" {
 		return errors.New("unable to determine current path")
 	}
+	jFile := filepath.Join("exercises", exercise, "canonical-data.json")
 	// find and read the json source file
 	jPath, jOri, jCommit := getPath(jFile)
 	jSrc, err := ioutil.ReadFile(filepath.Join(jPath, jFile))
@@ -93,7 +94,7 @@ func getPath(jFile string) (jPath, jOri, jCommit string) {
 	if jPath = os.Getenv("EXTEST"); jPath > "" {
 		return jPath, "local file", "" // override
 	}
-	c := exec.Command("git", "log", "-1", "--oneline")
+	c := exec.Command("git", "log", "-1", "--oneline", jFile)
 	c.Dir = dirMetadata
 	ori, err := c.Output()
 	if err != nil {

data/tracks/haskell/exercises/accumulate/src/Accumulate.hs

@@ -1,4 +1,4 @@
 module Accumulate (accumulate) where
 
 accumulate :: (a -> b) -> [a] -> [b]
-accumulate = undefined
+accumulate = error "You need to implement this function."

data/tracks/haskell/exercises/all-your-base/src/Base.hs

@@ -1,4 +1,4 @@
 module Base (rebase) where
 
 rebase :: Integral a => a -> a -> [a] -> Maybe [a]
-rebase inputBase outputBase inputDigits = undefined
+rebase inputBase outputBase inputDigits = error "You need to implement this function."

data/tracks/haskell/exercises/allergies/src/Allergies.hs

@@ -11,7 +11,7 @@ data Allergen = Eggs
               deriving (Eq)
 
 allergies :: Int -> [Allergen]
-allergies = undefined
+allergies = error "You need to implement this function."
 
 isAllergicTo :: Allergen -> Int -> Bool
-isAllergicTo = undefined
+isAllergicTo = error "You need to implement this function."

data/tracks/haskell/exercises/alphametics/src/Alphametics.hs

@@ -1,4 +1,4 @@
 module Alphametics (solve) where
 
 solve :: String -> Maybe [(Char, Int)]
-solve puzzle = undefined
+solve puzzle = error "You need to implement this function."

data/tracks/haskell/exercises/anagram/src/Anagram.hs

@@ -1,4 +1,4 @@
 module Anagram (anagramsFor) where
 
 anagramsFor :: String -> [String] -> [String]
-anagramsFor = undefined
+anagramsFor = error "You need to implement this function."

data/tracks/haskell/exercises/atbash-cipher/src/Atbash.hs

@@ -1,7 +1,7 @@
 module Atbash (decode, encode) where
 
 decode :: String -> String
-decode = undefined
+decode = error "You need to implement this function."
 
 encode :: String -> String
-encode = undefined
+encode = error "You need to implement this function."