From 95f4609a0f9599d89ea21b90a857e2c79e9e5538 Mon Sep 17 00:00:00 2001 From: lucaferranti Date: Sat, 16 Mar 2024 15:05:09 +0200 Subject: [PATCH] forth setup --- config.json | 34 +- .../practice/forth/.docs/instructions.md | 23 ++ exercises/practice/forth/.meta/config.json | 15 + exercises/practice/forth/.meta/reference.chpl | 0 exercises/practice/forth/.meta/tests.toml | 157 +++++++++ exercises/practice/forth/Mason.toml | 5 + exercises/practice/forth/src/forth.chpl | 3 + exercises/practice/forth/test/tests.chpl | 329 ++++++++++++++++++ 8 files changed, 553 insertions(+), 13 deletions(-) create mode 100644 exercises/practice/forth/.docs/instructions.md create mode 100644 exercises/practice/forth/.meta/config.json create mode 100644 exercises/practice/forth/.meta/reference.chpl create mode 100644 exercises/practice/forth/.meta/tests.toml create mode 100644 exercises/practice/forth/Mason.toml create mode 100644 exercises/practice/forth/src/forth.chpl create mode 100644 exercises/practice/forth/test/tests.chpl diff --git a/config.json b/config.json index f1d7e81..3a49806 100644 --- a/config.json +++ b/config.json @@ -8,9 +8,6 @@ "representer": false, "analyzer": false }, - "test_runner": { - "average_run_time": 10 - }, "blurb": "Chapel is a programming language designed for productive parallel computing at scale.", "version": 3, "online_editor": { @@ -18,6 +15,9 @@ "indent_size": 2, "highlightjs_language": "chapel" }, + "test_runner": { + "average_run_time": 10 + }, "files": { "solution": [ "src/%{kebab_slug}.chpl" @@ -209,19 +209,17 @@ "practices": [], "prerequisites": [], "difficulty": 1 + }, + { + "slug": "forth", + "name": "Forth", + "uuid": "48dd93c3-6fa4-4e9c-a973-6fdbd3a640a5", + "practices": [], + "prerequisites": [], + "difficulty": 10 } ] }, - "tags": [ - "execution_mode/compiled", - "paradigm/imperative", - "paradigm/object_oriented", - "platform/linux", - "platform/mac", - "runtime/standalone_executable", - "typing/static", - "used_for/scientific_calculations" - ], "key_features": [ { "title": "Open source", @@ -253,5 +251,15 @@ "content": "Chapel is a great fit for applications involving heavy computations or big data analysis", "icon": "scientific" } + ], + "tags": [ + "execution_mode/compiled", + "paradigm/imperative", + "paradigm/object_oriented", + "platform/linux", + "platform/mac", + "runtime/standalone_executable", + "typing/static", + "used_for/scientific_calculations" ] } diff --git a/exercises/practice/forth/.docs/instructions.md b/exercises/practice/forth/.docs/instructions.md new file mode 100644 index 0000000..91ad26e --- /dev/null +++ b/exercises/practice/forth/.docs/instructions.md @@ -0,0 +1,23 @@ +# Instructions + +Implement an evaluator for a very simple subset of Forth. + +[Forth][forth] +is a stack-based programming language. +Implement a very basic evaluator for a small subset of Forth. + +Your evaluator has to support the following words: + +- `+`, `-`, `*`, `/` (integer arithmetic) +- `DUP`, `DROP`, `SWAP`, `OVER` (stack manipulation) + +Your evaluator also has to support defining new words using the customary syntax: `: word-name definition ;`. + +To keep things simple the only data type you need to support is signed integers of at least 16 bits size. + +You should use the following rules for the syntax: a number is a sequence of one or more (ASCII) digits, a word is a sequence of one or more letters, digits, symbols or punctuation that is not a number. +(Forth probably uses slightly different rules, but this is close enough.) + +Words are case-insensitive. + +[forth]: https://en.wikipedia.org/wiki/Forth_%28programming_language%29 diff --git a/exercises/practice/forth/.meta/config.json b/exercises/practice/forth/.meta/config.json new file mode 100644 index 0000000..d8a774d --- /dev/null +++ b/exercises/practice/forth/.meta/config.json @@ -0,0 +1,15 @@ +{ + "authors": [], + "files": { + "solution": [ + "src/forth.chpl" + ], + "test": [ + "test/tests.chpl" + ], + "example": [ + ".meta/reference.chpl" + ] + }, + "blurb": "Implement an evaluator for a very simple subset of Forth." +} diff --git a/exercises/practice/forth/.meta/reference.chpl b/exercises/practice/forth/.meta/reference.chpl new file mode 100644 index 0000000..e69de29 diff --git a/exercises/practice/forth/.meta/tests.toml b/exercises/practice/forth/.meta/tests.toml new file mode 100644 index 0000000..c9c1d63 --- /dev/null +++ b/exercises/practice/forth/.meta/tests.toml @@ -0,0 +1,157 @@ +# This is an auto-generated file. +# +# Regenerating this file via `configlet sync` will: +# - Recreate every `description` key/value pair +# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications +# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion) +# - Preserve any other key/value pair +# +# As user-added comments (using the # character) will be removed when this file +# is regenerated, comments can be added via a `comment` key. + +[9962203f-f00a-4a85-b404-8a8ecbcec09d] +description = "parsing and numbers -> numbers just get pushed onto the stack" + +[fd7a8da2-6818-4203-a866-fed0714e7aa0] +description = "parsing and numbers -> pushes negative numbers onto the stack" + +[9e69588e-a3d8-41a3-a371-ea02206c1e6e] +description = "addition -> can add two numbers" + +[52336dd3-30da-4e5c-8523-bdf9a3427657] +description = "addition -> errors if there is nothing on the stack" + +[06efb9a4-817a-435e-b509-06166993c1b8] +description = "addition -> errors if there is only one value on the stack" + +[09687c99-7bbc-44af-8526-e402f997ccbf] +description = "subtraction -> can subtract two numbers" + +[5d63eee2-1f7d-4538-b475-e27682ab8032] +description = "subtraction -> errors if there is nothing on the stack" + +[b3cee1b2-9159-418a-b00d-a1bb3765c23b] +description = "subtraction -> errors if there is only one value on the stack" + +[5df0ceb5-922e-401f-974d-8287427dbf21] +description = "multiplication -> can multiply two numbers" + +[9e004339-15ac-4063-8ec1-5720f4e75046] +description = "multiplication -> errors if there is nothing on the stack" + +[8ba4b432-9f94-41e0-8fae-3b3712bd51b3] +description = "multiplication -> errors if there is only one value on the stack" + +[e74c2204-b057-4cff-9aa9-31c7c97a93f5] +description = "division -> can divide two numbers" + +[54f6711c-4b14-4bb0-98ad-d974a22c4620] +description = "division -> performs integer division" + +[a5df3219-29b4-4d2f-b427-81f82f42a3f1] +description = "division -> errors if dividing by zero" + +[1d5bb6b3-6749-4e02-8a79-b5d4d334cb8a] +description = "division -> errors if there is nothing on the stack" + +[d5547f43-c2ff-4d5c-9cb0-2a4f6684c20d] +description = "division -> errors if there is only one value on the stack" + +[ee28d729-6692-4a30-b9be-0d830c52a68c] +description = "combined arithmetic -> addition and subtraction" + +[40b197da-fa4b-4aca-a50b-f000d19422c1] +description = "combined arithmetic -> multiplication and division" + +[c5758235-6eef-4bf6-ab62-c878e50b9957] +description = "dup -> copies a value on the stack" + +[f6889006-5a40-41e7-beb3-43b09e5a22f4] +description = "dup -> copies the top value on the stack" + +[40b7569c-8401-4bd4-a30d-9adf70d11bc4] +description = "dup -> errors if there is nothing on the stack" + +[1971da68-1df2-4569-927a-72bf5bb7263c] +description = "drop -> removes the top value on the stack if it is the only one" + +[8929d9f2-4a78-4e0f-90ad-be1a0f313fd9] +description = "drop -> removes the top value on the stack if it is not the only one" + +[6dd31873-6dd7-4cb8-9e90-7daa33ba045c] +description = "drop -> errors if there is nothing on the stack" + +[3ee68e62-f98a-4cce-9e6c-8aae6c65a4e3] +description = "swap -> swaps the top two values on the stack if they are the only ones" + +[8ce869d5-a503-44e4-ab55-1da36816ff1c] +description = "swap -> swaps the top two values on the stack if they are not the only ones" + +[74ba5b2a-b028-4759-9176-c5c0e7b2b154] +description = "swap -> errors if there is nothing on the stack" + +[dd52e154-5d0d-4a5c-9e5d-73eb36052bc8] +description = "swap -> errors if there is only one value on the stack" + +[a2654074-ba68-4f93-b014-6b12693a8b50] +description = "over -> copies the second element if there are only two" + +[c5b51097-741a-4da7-8736-5c93fa856339] +description = "over -> copies the second element if there are more than two" + +[6e1703a6-5963-4a03-abba-02e77e3181fd] +description = "over -> errors if there is nothing on the stack" + +[ee574dc4-ef71-46f6-8c6a-b4af3a10c45f] +description = "over -> errors if there is only one value on the stack" + +[ed45cbbf-4dbf-4901-825b-54b20dbee53b] +description = "user-defined words -> can consist of built-in words" + +[2726ea44-73e4-436b-bc2b-5ff0c6aa014b] +description = "user-defined words -> execute in the right order" + +[9e53c2d0-b8ef-4ad8-b2c9-a559b421eb33] +description = "user-defined words -> can override other user-defined words" + +[669db3f3-5bd6-4be0-83d1-618cd6e4984b] +description = "user-defined words -> can override built-in words" + +[588de2f0-c56e-4c68-be0b-0bb1e603c500] +description = "user-defined words -> can override built-in operators" + +[ac12aaaf-26c6-4a10-8b3c-1c958fa2914c] +description = "user-defined words -> can use different words with the same name" + +[53f82ef0-2750-4ccb-ac04-5d8c1aefabb1] +description = "user-defined words -> can define word that uses word with the same name" + +[35958cee-a976-4a0f-9378-f678518fa322] +description = "user-defined words -> cannot redefine non-negative numbers" + +[df5b2815-3843-4f55-b16c-c3ed507292a7] +description = "user-defined words -> cannot redefine negative numbers" + +[5180f261-89dd-491e-b230-62737e09806f] +description = "user-defined words -> errors if executing a non-existent word" + +[3c8bfef3-edbb-49c1-9993-21d4030043cb] +description = "user-defined words -> only defines locally" + +[7b83bb2e-b0e8-461f-ad3b-96ee2e111ed6] +description = "case-insensitivity -> DUP is case-insensitive" + +[339ed30b-f5b4-47ff-ab1c-67591a9cd336] +description = "case-insensitivity -> DROP is case-insensitive" + +[ee1af31e-1355-4b1b-bb95-f9d0b2961b87] +description = "case-insensitivity -> SWAP is case-insensitive" + +[acdc3a49-14c8-4cc2-945d-11edee6408fa] +description = "case-insensitivity -> OVER is case-insensitive" + +[5934454f-a24f-4efc-9fdd-5794e5f0c23c] +description = "case-insensitivity -> user-defined words are case-insensitive" + +[037d4299-195f-4be7-a46d-f07ca6280a06] +description = "case-insensitivity -> definitions are case-insensitive" diff --git a/exercises/practice/forth/Mason.toml b/exercises/practice/forth/Mason.toml new file mode 100644 index 0000000..ece87d6 --- /dev/null +++ b/exercises/practice/forth/Mason.toml @@ -0,0 +1,5 @@ +[brick] +name="forth" +version="0.1.0" +chplVersion="1.33.0" +type="application" diff --git a/exercises/practice/forth/src/forth.chpl b/exercises/practice/forth/src/forth.chpl new file mode 100644 index 0000000..24d13dd --- /dev/null +++ b/exercises/practice/forth/src/forth.chpl @@ -0,0 +1,3 @@ +module Forth { + // write your solution here +} diff --git a/exercises/practice/forth/test/tests.chpl b/exercises/practice/forth/test/tests.chpl new file mode 100644 index 0000000..4a9edb4 --- /dev/null +++ b/exercises/practice/forth/test/tests.chpl @@ -0,0 +1,329 @@ +use UnitTest; + +use Forth; + +proc testParsingAndNumbersNumbersJustGetPushedOntoTheStack(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 3 4 5"]), [1, 2, 3, 4, 5]); +} + +proc testParsingAndNumbersPushesNegativeNumbersOntoTheStack(test : borrowed Test) throws { + test.assertEqual(evaluate(["-1 -2 -3 -4 -5"]), [-1, -2, -3, -4, -5]); +} + +proc testAdditionCanAddTwoNumbers(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 +"]), [3]); +} + +proc testAdditionErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["+"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testAdditionErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 +"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testSubtractionCanSubtractTwoNumbers(test : borrowed Test) throws { + test.assertEqual(evaluate(["3 4 -"]), [-1]); +} + +proc testSubtractionErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["-"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testSubtractionErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 -"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testMultiplicationCanMultiplyTwoNumbers(test : borrowed Test) throws { + test.assertEqual(evaluate(["2 4 *"]), [8]); +} + +proc testMultiplicationErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["*"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testMultiplicationErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 *"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testDivisionCanDivideTwoNumbers(test : borrowed Test) throws { + test.assertEqual(evaluate(["12 3 /"]), [4]); +} + +proc testDivisionPerformsIntegerDivision(test : borrowed Test) throws { + test.assertEqual(evaluate(["8 3 /"]), [2]); +} + +proc testDivisionErrorsIfDividingByZero(test : borrowed Test) throws { + try { + evaluate(["4 0 /"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "divide by zero"); + } catch e { + throw e; + } +} + +proc testDivisionErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["/"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testDivisionErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 /"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testCombinedArithmeticAdditionAndSubtraction(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 + 4 -"]), [-1]); +} + +proc testCombinedArithmeticMultiplicationAndDivision(test : borrowed Test) throws { + test.assertEqual(evaluate(["2 4 * 3 /"]), [2]); +} + +proc testDupCopiesAValueOnTheStack(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 dup"]), [1, 1]); +} + +proc testDupCopiesTheTopValueOnTheStack(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 dup"]), [1, 2, 2]); +} + +proc testDupErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["dup"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testDropRemovesTheTopValueOnTheStackIfItIsTheOnlyOne(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 drop"]), []); +} + +proc testDropRemovesTheTopValueOnTheStackIfItIsNotTheOnlyOne(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 drop"]), [1]); +} + +proc testDropErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["drop"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testSwapSwapsTheTopTwoValuesOnTheStackIfTheyAreTheOnlyOnes(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 swap"]), [2, 1]); +} + +proc testSwapSwapsTheTopTwoValuesOnTheStackIfTheyAreNotTheOnlyOnes(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 3 swap"]), [1, 3, 2]); +} + +proc testSwapErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["swap"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testSwapErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 swap"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testOverCopiesTheSecondElementIfThereAreOnlyTwo(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 over"]), [1, 2, 1]); +} + +proc testOverCopiesTheSecondElementIfThereAreMoreThanTwo(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 3 over"]), [1, 2, 3, 2]); +} + +proc testOverErrorsIfThereIsNothingOnTheStack(test : borrowed Test) throws { + try { + evaluate(["over"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "empty stack"); + } catch e { + throw e; + } +} + +proc testOverErrorsIfThereIsOnlyOneValueOnTheStack(test : borrowed Test) throws { + try { + evaluate(["1 over"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "only one value on the stack"); + } catch e { + throw e; + } +} + +proc testUserDefinedWordsCanConsistOfBuiltInWords(test : borrowed Test) throws { + test.assertEqual(evaluate([": dup-twice dup dup ;", "1 dup-twice"]), [1, 1, 1]); +} + +proc testUserDefinedWordsExecuteInTheRightOrder(test : borrowed Test) throws { + test.assertEqual(evaluate([": countup 1 2 3 ;", "countup"]), [1, 2, 3]); +} + +proc testUserDefinedWordsCanOverrideOtherUserDefinedWords(test : borrowed Test) throws { + test.assertEqual(evaluate([": foo dup ;", ": foo dup dup ;", "1 foo"]), [1, 1, 1]); +} + +proc testUserDefinedWordsCanOverrideBuiltInWords(test : borrowed Test) throws { + test.assertEqual(evaluate([": swap dup ;", "1 swap"]), [1, 1]); +} + +proc testUserDefinedWordsCanOverrideBuiltInOperators(test : borrowed Test) throws { + test.assertEqual(evaluate([": + * ;", "3 4 +"]), [12]); +} + +proc testUserDefinedWordsCanUseDifferentWordsWithTheSameName(test : borrowed Test) throws { + test.assertEqual(evaluate([": foo 5 ;", ": bar foo ;", ": foo 6 ;", "bar foo"]), [5, 6]); +} + +proc testUserDefinedWordsCanDefineWordThatUsesWordWithTheSameName(test : borrowed Test) throws { + test.assertEqual(evaluate([": foo 10 ;", ": foo foo 1 + ;", "foo"]), [11]); +} + +proc testUserDefinedWordsCannotRedefineNonNegativeNumbers(test : borrowed Test) throws { + try { + evaluate([": 1 2 ;"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "illegal operation"); + } catch e { + throw e; + } +} + +proc testUserDefinedWordsCannotRedefineNegativeNumbers(test : borrowed Test) throws { + try { + evaluate([": -1 2 ;"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "illegal operation"); + } catch e { + throw e; + } +} + +proc testUserDefinedWordsErrorsIfExecutingANonExistentWord(test : borrowed Test) throws { + try { + evaluate(["foo"]); + throw new AssertionError("Function was expected to throw an error"); + } catch e : IllegalArgumentError { + test.assertEqual(e.message(), "undefined operation"); + } catch e { + throw e; + } +} + +proc testUserDefinedWordsOnlyDefinesLocally(test : borrowed Test) throws { + var result1 = evaluate([": + - ;", "1 1 +"]); + var result2 = evaluate(["1 1 +"]); + test.assertEqual([result1, result2], [[0], [2]]); +} + +proc testCaseInsensitivityDupIsCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 DUP Dup dup"]), [1, 1, 1, 1]); +} + +proc testCaseInsensitivityDropIsCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 3 4 DROP Drop drop"]), [1]); +} + +proc testCaseInsensitivitySwapIsCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 SWAP 3 Swap 4 swap"]), [2, 3, 4, 1]); +} + +proc testCaseInsensitivityOverIsCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate(["1 2 OVER Over over"]), [1, 2, 1, 2, 1]); +} + +proc testCaseInsensitivityUserDefinedWordsAreCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate([": foo dup ;", "1 FOO Foo foo"]), [1, 1, 1, 1]); +} + +proc testCaseInsensitivityDefinitionsAreCaseInsensitive(test : borrowed Test) throws { + test.assertEqual(evaluate([": SWAP DUP Dup dup ;", "1 swap"]), [1, 1, 1, 1]); +} + +UnitTest.main();