anoma/juvix
1
1
Fork 0
mirror of https://github.com/anoma/juvix.git synced 2024-12-14 17:32:00 +03:00
Code Issues Projects Releases Wiki Activity
407a74004c
juvix/test/Compilation/Positive.hs

374 lines
11 KiB
Haskell
Raw Normal View History

Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
module Compilation.Positive where
import Base
import Compilation.Base
data PosTest = PosTest
{ _name :: String,
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
_dir :: Path Abs Dir,
_file :: Path Abs File,
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
_assertionMode :: CompileAssertionMode,
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
_expectedFile :: Path Abs File
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
}
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
makeLenses ''PosTest
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
fromTest :: PosTest -> TestTree
fromTest = mkTest . toTestDescr
root :: Path Abs Dir
root = relToProject $(mkRelDir "tests/Compilation/positive/")
toTestDescr :: PosTest -> TestDescr
toTestDescr PosTest {..} =
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
let tRoot = _dir
file' = _file
expected' = _expectedFile
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
in TestDescr
{ _testName = _name,
_testRoot = tRoot,
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
_testAssertion = Steps $ compileAssertion _assertionMode file' expected'
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
}
allTests :: TestTree
allTests =
testGroup
"Juvix compilation pipeline positive tests"
New compilation pipeline (#1832) * Depends on PR #1824 * Closes #1556 * Closes #1825 * Closes #1843 * Closes #1729 * Closes #1596 * Closes #1343 * Closes #1382 * Closes #1867 * Closes #1876 * Changes the `juvix compile` command to use the new pipeline. * Removes the `juvix dev minic` command and the `BackendC` tests. * Adds the `juvix eval` command. * Fixes bugs in the Nat-to-integer conversion. * Fixes bugs in the Internal-to-Core and Core-to-Core.Stripped translations. * Fixes bugs in the RemoveTypeArgs transformation. * Fixes bugs in lambda-lifting (incorrect de Bruijn indices in the types of added binders). * Fixes several other bugs in the compilation pipeline. * Adds a separate EtaExpandApps transformation to avoid quadratic runtime in the Internal-to-Core translation due to repeated calls to etaExpandApps. * Changes Internal-to-Core to avoid generating matches on values which don't have an inductive type. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev> Co-authored-by: janmasrovira <janmasrovira@gmail.com>
2023-03-14 18:24:07 +03:00
(map (mkTest . toTestDescr) tests)
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
posTest' :: CompileAssertionMode -> String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
posTest' _assertionMode _name rdir rfile routfile =
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
let _dir = root <//> rdir
_file = _dir <//> rfile
_expectedFile = root <//> routfile
in PosTest {..}
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
posTestStdin :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> Text -> PosTest
posTestStdin _name rdir rfile routfile _stdinText =
let t = posTest _name rdir rfile routfile
in t
{ _assertionMode = CompileOnly _stdinText
}
New compilation pipeline (#1832) * Depends on PR #1824 * Closes #1556 * Closes #1825 * Closes #1843 * Closes #1729 * Closes #1596 * Closes #1343 * Closes #1382 * Closes #1867 * Closes #1876 * Changes the `juvix compile` command to use the new pipeline. * Removes the `juvix dev minic` command and the `BackendC` tests. * Adds the `juvix eval` command. * Fixes bugs in the Nat-to-integer conversion. * Fixes bugs in the Internal-to-Core and Core-to-Core.Stripped translations. * Fixes bugs in the RemoveTypeArgs transformation. * Fixes bugs in lambda-lifting (incorrect de Bruijn indices in the types of added binders). * Fixes several other bugs in the compilation pipeline. * Adds a separate EtaExpandApps transformation to avoid quadratic runtime in the Internal-to-Core translation due to repeated calls to etaExpandApps. * Changes Internal-to-Core to avoid generating matches on values which don't have an inductive type. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev> Co-authored-by: janmasrovira <janmasrovira@gmail.com>
2023-03-14 18:24:07 +03:00
posTest :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
posTest = posTest' EvalAndCompile
New compilation pipeline (#1832) * Depends on PR #1824 * Closes #1556 * Closes #1825 * Closes #1843 * Closes #1729 * Closes #1596 * Closes #1343 * Closes #1382 * Closes #1867 * Closes #1876 * Changes the `juvix compile` command to use the new pipeline. * Removes the `juvix dev minic` command and the `BackendC` tests. * Adds the `juvix eval` command. * Fixes bugs in the Nat-to-integer conversion. * Fixes bugs in the Internal-to-Core and Core-to-Core.Stripped translations. * Fixes bugs in the RemoveTypeArgs transformation. * Fixes bugs in lambda-lifting (incorrect de Bruijn indices in the types of added binders). * Fixes several other bugs in the compilation pipeline. * Adds a separate EtaExpandApps transformation to avoid quadratic runtime in the Internal-to-Core translation due to repeated calls to etaExpandApps. * Changes Internal-to-Core to avoid generating matches on values which don't have an inductive type. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev> Co-authored-by: janmasrovira <janmasrovira@gmail.com>
2023-03-14 18:24:07 +03:00
-- tests which use large integers are only evaluated but not compiled
posTestEval :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
posTestEval = posTest' EvalOnly
New compilation pipeline (#1832) * Depends on PR #1824 * Closes #1556 * Closes #1825 * Closes #1843 * Closes #1729 * Closes #1596 * Closes #1343 * Closes #1382 * Closes #1867 * Closes #1876 * Changes the `juvix compile` command to use the new pipeline. * Removes the `juvix dev minic` command and the `BackendC` tests. * Adds the `juvix eval` command. * Fixes bugs in the Nat-to-integer conversion. * Fixes bugs in the Internal-to-Core and Core-to-Core.Stripped translations. * Fixes bugs in the RemoveTypeArgs transformation. * Fixes bugs in lambda-lifting (incorrect de Bruijn indices in the types of added binders). * Fixes several other bugs in the compilation pipeline. * Adds a separate EtaExpandApps transformation to avoid quadratic runtime in the Internal-to-Core translation due to repeated calls to etaExpandApps. * Changes Internal-to-Core to avoid generating matches on values which don't have an inductive type. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev> Co-authored-by: janmasrovira <janmasrovira@gmail.com>
2023-03-14 18:24:07 +03:00
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
tests :: [PosTest]
tests =
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
[ posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test001: Arithmetic operators"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test001.juvix")
$(mkRelFile "out/test001.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test002: Arithmetic operators inside lambdas"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test002.juvix")
$(mkRelFile "out/test002.out"),
Add test for div and mod (#1741)
2023-01-19 12:47:12 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test003: Integer arithmetic"
Add test for div and mod (#1741)
2023-01-19 12:47:12 +03:00
$(mkRelDir ".")
$(mkRelFile "test003.juvix")
$(mkRelFile "out/test003.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test004: IO builtins"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test004.juvix")
$(mkRelFile "out/test004.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test005: Higher-order functions"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test005.juvix")
$(mkRelFile "out/test005.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test006: If-then-else and lazy boolean operators"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test006.juvix")
$(mkRelFile "out/test006.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test007: Pattern matching and lambda-case"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test007.juvix")
$(mkRelFile "out/test007.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test008: Recursion"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test008.juvix")
$(mkRelFile "out/test008.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test009: Tail recursion"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test009.juvix")
$(mkRelFile "out/test009.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test010: Let"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test010.juvix")
$(mkRelFile "out/test010.out"),
New compilation pipeline (#1832) * Depends on PR #1824 * Closes #1556 * Closes #1825 * Closes #1843 * Closes #1729 * Closes #1596 * Closes #1343 * Closes #1382 * Closes #1867 * Closes #1876 * Changes the `juvix compile` command to use the new pipeline. * Removes the `juvix dev minic` command and the `BackendC` tests. * Adds the `juvix eval` command. * Fixes bugs in the Nat-to-integer conversion. * Fixes bugs in the Internal-to-Core and Core-to-Core.Stripped translations. * Fixes bugs in the RemoveTypeArgs transformation. * Fixes bugs in lambda-lifting (incorrect de Bruijn indices in the types of added binders). * Fixes several other bugs in the compilation pipeline. * Adds a separate EtaExpandApps transformation to avoid quadratic runtime in the Internal-to-Core translation due to repeated calls to etaExpandApps. * Changes Internal-to-Core to avoid generating matches on values which don't have an inductive type. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev> Co-authored-by: janmasrovira <janmasrovira@gmail.com>
2023-03-14 18:24:07 +03:00
posTestEval
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test011: Tail recursion: Fibonacci numbers in linear time"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test011.juvix")
$(mkRelFile "out/test011.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test012: Trees"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test012.juvix")
$(mkRelFile "out/test012.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test013: Functions returning functions with variable capture"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test013.juvix")
$(mkRelFile "out/test013.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test014: Arithmetic"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test014.juvix")
$(mkRelFile "out/test014.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test015: Local functions with free variables"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test015.juvix")
$(mkRelFile "out/test015.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test016: Recursion through higher-order functions"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test016.juvix")
$(mkRelFile "out/test016.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test017: Tail recursion through higher-order functions"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test017.juvix")
$(mkRelFile "out/test017.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test018: Higher-order functions and recursion"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test018.juvix")
$(mkRelFile "out/test018.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test019: Self-application"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test019.juvix")
$(mkRelFile "out/test019.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test020: Recursive functions: McCarthy's 91 function, subtraction by increments"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test020.juvix")
$(mkRelFile "out/test020.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test021: Fast exponentiation"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test021.juvix")
$(mkRelFile "out/test021.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test022: Lists"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test022.juvix")
$(mkRelFile "out/test022.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test023: Mutual recursion"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test023.juvix")
$(mkRelFile "out/test023.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test024: Nested binders with variable capture"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test024.juvix")
$(mkRelFile "out/test024.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test025: Euclid's algorithm"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test025.juvix")
$(mkRelFile "out/test025.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test026: Functional queues"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test026.juvix")
$(mkRelFile "out/test026.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test027: Church numerals"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test027.juvix")
$(mkRelFile "out/test027.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test028: Streams without memoization"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test028.juvix")
$(mkRelFile "out/test028.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test029: Ackermann function"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test029.juvix")
$(mkRelFile "out/test029.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test030: Ackermann function (higher-order definition)"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test030.juvix")
$(mkRelFile "out/test030.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test031: Nested lists"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test031.juvix")
$(mkRelFile "out/test031.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test032: Merge sort"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test032.juvix")
$(mkRelFile "out/test032.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test033: Eta-expansion of builtins and constructors"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test033.juvix")
$(mkRelFile "out/test033.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test034: Recursive let"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test034.juvix")
$(mkRelFile "out/test034.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test035: Pattern matching"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test035.juvix")
$(mkRelFile "out/test035.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test036: Eta-expansion"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test036.juvix")
$(mkRelFile "out/test036.out"),
Typecheck let expressions (#1712)
2023-01-17 11:41:07 +03:00
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test037: Applications with lets and cases in function position"
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
$(mkRelDir ".")
$(mkRelFile "test037.juvix")
Add compilation of complex pattern matching to case (#1824) This PR adds the `match-to-case` Core transformation. This transforms pattern matching nodes to a sequence of case and let nodes. ## High level description Each branch of the match is compiled to a lambda. In the combined match Each branch of the match is compiled to a lambda. These lambdas are combined in nested lets and each lambda is called in turn as each branch gets checked. The lambda corresponding to the first branch gets called first, if the pattern match in the branch fails, the lambda corresponding to the next branch is called and so on. If no branches match then a lambda is called which returns a fail node. Conceptually: <table> <tr> <td> Core </td> <td> Transformed </td> </tr> <tr> <td> ``` match v1 .. vn { b1 b2 ... bk } ``` </td> <td> ``` λ let c0 := λ FAIL in let ck := λ {...} in ... let c1 := λ {...} in c1 v1 ... vn ``` </td> </tr> </table> The patterns on each branch are compiled to either let bindings (pattern binders) or case expressions (constructor patterns). Auxillary bindings are added in the case of nested constructor patterns. The default branch in each case expression has a call to the lambda corresponding to the next branch of the match. This is because the default branch is reached if the pattern match fails. <table> <tr> <td> Pattern match </td> <td> Transformed </td> </tr> <tr> <td> ``` suc (suc n) ↦ n ``` </td> <td> ``` case ?$0 of { suc arg_8 := case ?$0 of { suc n := let n := ?$0 in n$0; _ := ?$2 ?$1 }; _ := ?$1 ?$0 } ``` </td> </tr> </table> The body of each branch is wrapped in let bindings so that the indicies of bound variables in the body point to the correct variables in the compiled expression. This is necessary because the auxiliary bindings added for nested constructor patterns will cause the original indicies to be offset. Finally, the free variables in the match branch body need to be shifted by all the bindings we've added as part of the compilation. ## Examples ### Single wildcard <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f _ := 1; ``` </td> <td> ``` λ? match ?$0 with { _ω309 ↦ ? 1 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? let _ω309 := ?$0 in let _ω309 := ?$0 in 1 in ?$0 ?$2 ``` </td> </tr> </table> ### Single binder <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f n := n; ``` </td> <td> ``` λ? match ?$0 with { n ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? let n := ?$0 in let n := ?$0 in n$0 in ?$0 ?$2 ``` </td> </tr> </table> ### Single Constructor <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc n) := n; ``` </td> <td> ``` λ? match ?$0 with { suc n ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$1 ?$0 } in ?$0 ?$2 ``` </td> </tr> </table> ### Nested Constructor <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc (suc n)) := n; ``` </td> <td> ``` λ? match ?$0 with { suc (suc n) ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc arg_8 := case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$2 ?$1 }; _ := ?$1 ?$0 } in ?$0 ?$2 ``` </td> </tr> </table> ### Multiple Branches <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc n) := n; f zero := 0; ``` </td> <td> ``` λ? match ?$0 with { suc n ↦ n$0; zero ↦ ? 0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { zero := ? 0; _ := ?$1 ?$0 } in let ? := λ? case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$1 ?$0 } in ?$0 ?$3 ``` </td> </tr> </table> ### Nested case with captured variable <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat -> Nat; f n m := case m | suc k := n + k; ``` </td> <td> ``` f = λ? λ? match ?$1, ?$0 with { n, m ↦ match m$0 with { suc k ↦ + n$2 k$0 } } ``` </td> <td> ``` λ? λ? let ? := λ? λ? fail "Non-exhaustive patterns" in let ? := λ? λ? let n := ?$1 in let m := ?$1 in let n := ?$1 in let m := ?$1 in let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc k := let k := ?$0 in let k := ?$0 in + n$6 k$0; _ := ?$1 ?$0 } in ?$0 m$2 in ?$0 ?$3 ?$2 ``` </td> </tr> </table> ## Testing The `tests/Compilation/positive` tests are run up to the Core evaluator with `match-to-case` and `nat-to-int` transformations on Core turned on. --------- Co-authored-by: Lukasz Czajka <lukasz@heliax.dev>
2023-02-15 13:30:12 +03:00
$(mkRelFile "out/test037.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test038: Simple case expression"
Add compilation of complex pattern matching to case (#1824) This PR adds the `match-to-case` Core transformation. This transforms pattern matching nodes to a sequence of case and let nodes. ## High level description Each branch of the match is compiled to a lambda. In the combined match Each branch of the match is compiled to a lambda. These lambdas are combined in nested lets and each lambda is called in turn as each branch gets checked. The lambda corresponding to the first branch gets called first, if the pattern match in the branch fails, the lambda corresponding to the next branch is called and so on. If no branches match then a lambda is called which returns a fail node. Conceptually: <table> <tr> <td> Core </td> <td> Transformed </td> </tr> <tr> <td> ``` match v1 .. vn { b1 b2 ... bk } ``` </td> <td> ``` λ let c0 := λ FAIL in let ck := λ {...} in ... let c1 := λ {...} in c1 v1 ... vn ``` </td> </tr> </table> The patterns on each branch are compiled to either let bindings (pattern binders) or case expressions (constructor patterns). Auxillary bindings are added in the case of nested constructor patterns. The default branch in each case expression has a call to the lambda corresponding to the next branch of the match. This is because the default branch is reached if the pattern match fails. <table> <tr> <td> Pattern match </td> <td> Transformed </td> </tr> <tr> <td> ``` suc (suc n) ↦ n ``` </td> <td> ``` case ?$0 of { suc arg_8 := case ?$0 of { suc n := let n := ?$0 in n$0; _ := ?$2 ?$1 }; _ := ?$1 ?$0 } ``` </td> </tr> </table> The body of each branch is wrapped in let bindings so that the indicies of bound variables in the body point to the correct variables in the compiled expression. This is necessary because the auxiliary bindings added for nested constructor patterns will cause the original indicies to be offset. Finally, the free variables in the match branch body need to be shifted by all the bindings we've added as part of the compilation. ## Examples ### Single wildcard <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f _ := 1; ``` </td> <td> ``` λ? match ?$0 with { _ω309 ↦ ? 1 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? let _ω309 := ?$0 in let _ω309 := ?$0 in 1 in ?$0 ?$2 ``` </td> </tr> </table> ### Single binder <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f n := n; ``` </td> <td> ``` λ? match ?$0 with { n ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? let n := ?$0 in let n := ?$0 in n$0 in ?$0 ?$2 ``` </td> </tr> </table> ### Single Constructor <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc n) := n; ``` </td> <td> ``` λ? match ?$0 with { suc n ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$1 ?$0 } in ?$0 ?$2 ``` </td> </tr> </table> ### Nested Constructor <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc (suc n)) := n; ``` </td> <td> ``` λ? match ?$0 with { suc (suc n) ↦ n$0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc arg_8 := case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$2 ?$1 }; _ := ?$1 ?$0 } in ?$0 ?$2 ``` </td> </tr> </table> ### Multiple Branches <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat; f (suc n) := n; f zero := 0; ``` </td> <td> ``` λ? match ?$0 with { suc n ↦ n$0; zero ↦ ? 0 } ``` </td> <td> ``` λ? let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { zero := ? 0; _ := ?$1 ?$0 } in let ? := λ? case ?$0 of { suc n := let n := ?$0 in let n := ?$0 in n$0; _ := ?$1 ?$0 } in ?$0 ?$3 ``` </td> </tr> </table> ### Nested case with captured variable <table> <tr> <td> Juvix </td> <td> Core </td> <td> Transformed Core </td> </tr> <tr> <td> ``` f : Nat -> Nat -> Nat; f n m := case m | suc k := n + k; ``` </td> <td> ``` f = λ? λ? match ?$1, ?$0 with { n, m ↦ match m$0 with { suc k ↦ + n$2 k$0 } } ``` </td> <td> ``` λ? λ? let ? := λ? λ? fail "Non-exhaustive patterns" in let ? := λ? λ? let n := ?$1 in let m := ?$1 in let n := ?$1 in let m := ?$1 in let ? := λ? fail "Non-exhaustive patterns" in let ? := λ? case ?$0 of { suc k := let k := ?$0 in let k := ?$0 in + n$6 k$0; _ := ?$1 ?$0 } in ?$0 m$2 in ?$0 ?$3 ?$2 ``` </td> </tr> </table> ## Testing The `tests/Compilation/positive` tests are run up to the Core evaluator with `match-to-case` and `nat-to-int` transformations on Core turned on. --------- Co-authored-by: Lukasz Czajka <lukasz@heliax.dev>
2023-02-15 13:30:12 +03:00
$(mkRelDir ".")
$(mkRelFile "test038.juvix")
Automatically detect and split mutually recursive blocks in let expressions (#1894) - Closes #1677
2023-03-17 14:05:55 +03:00
$(mkRelFile "out/test038.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test039: Mutually recursive let expression"
Automatically detect and split mutually recursive blocks in let expressions (#1894) - Closes #1677
2023-03-17 14:05:55 +03:00
$(mkRelDir ".")
$(mkRelFile "test039.juvix")
internal-to-core: Fix index shifting of pattern arguments (#1900)
2023-03-18 02:30:51 +03:00
$(mkRelFile "out/test039.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test040: Pattern matching nullary constructor"
internal-to-core: Fix index shifting of pattern arguments (#1900)
2023-03-18 02:30:51 +03:00
$(mkRelDir ".")
$(mkRelFile "test040.juvix")
Fix registration of builtin inductive axioms (#1901) builtin inductive axioms must be registered in the same pass as inductive types becuase inductive types may use builtin inductives in the types of their constructors. ``` builtin string axiom String : Type; type BoxedString := | boxed : String -> BoxedString; ``` The separate passes for processing functions and inductives was unnecessary. This commit combines `registerInductiveDefs` and `registerFunctionDefs` into a single pass over a modules statements
2023-03-20 13:00:22 +03:00
$(mkRelFile "out/test040.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test041: Use a builtin inductive in an inductive constructor"
Fix registration of builtin inductive axioms (#1901) builtin inductive axioms must be registered in the same pass as inductive types becuase inductive types may use builtin inductives in the types of their constructors. ``` builtin string axiom String : Type; type BoxedString := | boxed : String -> BoxedString; ``` The separate passes for processing functions and inductives was unnecessary. This commit combines `registerInductiveDefs` and `registerFunctionDefs` into a single pass over a modules statements
2023-03-20 13:00:22 +03:00
$(mkRelDir ".")
$(mkRelFile "test041.juvix")
Fix JuvixAsm validation (#1903) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-20 15:01:35 +03:00
$(mkRelFile "out/test041.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test042: Builtin string-to-nat"
Fix JuvixAsm validation (#1903) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-20 15:01:35 +03:00
$(mkRelDir ".")
$(mkRelFile "test042.juvix")
$(mkRelFile "out/test042.out"),
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test043: Builtin trace"
Fix JuvixAsm validation (#1903) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-20 15:01:35 +03:00
$(mkRelDir ".")
$(mkRelFile "test043.juvix")
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
$(mkRelFile "out/test043.out"),
posTestStdin
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test044: Builtin readline"
Fix bug in IO runtime (#1906) Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-21 17:34:46 +03:00
$(mkRelDir ".")
$(mkRelFile "test044.juvix")
$(mkRelFile "out/test044.out")
Fix bug with unregistered builtin bool (#1917) * Closes #1884
2023-03-24 12:29:57 +03:00
"a\n",
posTest
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
"Test045: Implicit builtin bool"
Fix bug with unregistered builtin bool (#1917) * Closes #1884
2023-03-24 12:29:57 +03:00
$(mkRelDir ".")
$(mkRelFile "test045.juvix")
Fix removal of polymorphic type arguments (#1954) * Closes #1930
2023-03-30 20:56:07 +03:00
$(mkRelFile "out/test045.out"),
posTest
"Test046: Polymorphic type arguments"
$(mkRelDir ".")
$(mkRelFile "test046.juvix")
Support local modules (#1872) Support local modules. --------- Co-authored-by: Paul Cadman <git@paulcadman.dev>
2023-03-31 16:57:37 +03:00
$(mkRelFile "out/test046.out"),
posTest
"Test047: Local Modules"
$(mkRelDir ".")
$(mkRelFile "test047.juvix")
Print quoted strings in the runtime (#1969) * Closes #1968
2023-04-04 12:29:02 +03:00
$(mkRelFile "out/test047.out"),
posTest
"Test048: String quoting"
$(mkRelDir ".")
$(mkRelFile "test048.juvix")
Add builtin integer type to the surface language (#1948) This PR adds a builtin integer type to the surface language that is compiled to the backend integer type. ## Inductive definition The `Int` type is defined in the standard library as: ``` builtin int type Int := | --- ofNat n represents the integer n ofNat : Nat -> Int | --- negSuc n represents the integer -(n + 1) negSuc : Nat -> Int; ``` ## New builtin functions defined in the standard library ``` intToString : Int -> String; + : Int -> Int -> Int; neg : Int -> Int; * : Int -> Int -> Int; - : Int -> Int -> Int; div : Int -> Int -> Int; mod : Int -> Int -> Int; == : Int -> Int -> Bool; <= : Int -> Int -> Bool; < : Int -> Int -> Bool; ``` Additional builtins required in the definition of the other builtins: ``` negNat : Nat -> Int; intSubNat : Nat -> Nat -> Int; nonNeg : Int -> Bool; ``` ## REPL types of literals In the REPL, non-negative integer literals have the inferred type `Nat`, negative integer literals have the inferred type `Int`. ``` Stdlib.Prelude> :t 1 Nat Stdlib.Prelude> :t -1 Int :t let x : Int := 1 in x Int ``` ## The standard library Prelude The definitions of `*`, `+`, `div` and `mod` are not exported from the standard library prelude as these would conflict with the definitions from `Stdlib.Data.Nat`. Stdlib.Prelude ``` open import Stdlib.Data.Int hiding {+;*;div;mod} public; ``` * Closes https://github.com/anoma/juvix/issues/1679 * Closes https://github.com/anoma/juvix/issues/1984 --------- Co-authored-by: Lukasz Czajka <lukasz@heliax.dev>
2023-04-13 10:16:49 +03:00
$(mkRelFile "out/test048.out"),
posTest
"Test049: Builtin Int"
$(mkRelDir ".")
$(mkRelFile "test049.juvix")
$(mkRelFile "out/test049.out"),
posTest
"Test050: Pattern matching with integers"
$(mkRelDir ".")
$(mkRelFile "test050.juvix")
Substitute calls after lambda lifting (#2031) - Closes #2006 During lambda lifting, we now substitute the calls to the lifted functions before recursively applying lambda lifting. This will slightly increase the amount of captured variables. However, I think this is the only way since we need all identifiers to have a type when recursing.
2023-04-26 13:56:44 +03:00
$(mkRelFile "out/test050.out"),
posTest
"Test051: Local recursive function using IO >>"
$(mkRelDir ".")
$(mkRelFile "test051.juvix")
Fix ordering of statements in Abstract -> Internal (#2040) - Closes #2039 - Closes #2055 - Depends on #2053 Changes in this pr: - Local modules are removed (flattened) in the translation abstract -> internal. - In the translation abstract -> internal we group definitions in mutually recursive blocks. These blocks can contain function definitions and type definitions. Previously we only handled functions. - The translation of Internal has been enhanced to handle these mutually recursive blocks. - Some improvements the pretty printer for internal (e.g. we now print builtin tags properly). - A "hack" that puts the builtin bool definition at the beginning of a module if present. This was the easiest way to handle the implicit dependency of the builtin stringToNat with bool in the internal-to-core translation. - A moderately sized test defining a simple lambda calculus involving and an evaluator for it. This example showcases mutually recursive types in juvix. --------- Co-authored-by: Jonathan Cubides <jonathan.cubides@uib.no>
2023-05-15 14:02:09 +03:00
$(mkRelFile "out/test051.out"),
posTest
Inlining (#2036) * Closes #1989 * Adds optimization phases to the pipline (specified by `opt-phase-eval`, `opt-phase-exec` and `opt-phase-geb` transformations). * Adds the `-O` option to the `compile` command to specify the optimization level. * Functions can be declared for inlining with the `inline` pragma: ``` {-# inline: true #-} const : {A B : Type} -> A -> B -> A; const x _ := x; ``` By default, the function is inlined only if it's fully applied. One can specify that a function (partially) applied to at least `n` explicit arguments should be inlined. ``` {-# inline: 2 #-} compose : {A B C : Type} -> (B -> C) -> (A -> B) -> A -> C; compose f g x := f (g x); ``` Then `compose f g` will be inlined, even though it's not fully applied. But `compose f` won't be inlined. * Non-recursive fully applied functions are automatically inlined if the height of the body term does not exceed the inlining depth limit, which can be specified with the `--inline` option to the `compile` command. * The pragma `inline: false` disables automatic inlining on a per-function basis.
2023-05-15 18:27:05 +03:00
"Test052: Simple lambda calculus"
Fix ordering of statements in Abstract -> Internal (#2040) - Closes #2039 - Closes #2055 - Depends on #2053 Changes in this pr: - Local modules are removed (flattened) in the translation abstract -> internal. - In the translation abstract -> internal we group definitions in mutually recursive blocks. These blocks can contain function definitions and type definitions. Previously we only handled functions. - The translation of Internal has been enhanced to handle these mutually recursive blocks. - Some improvements the pretty printer for internal (e.g. we now print builtin tags properly). - A "hack" that puts the builtin bool definition at the beginning of a module if present. This was the easiest way to handle the implicit dependency of the builtin stringToNat with bool in the internal-to-core translation. - A moderately sized test defining a simple lambda calculus involving and an evaluator for it. This example showcases mutually recursive types in juvix. --------- Co-authored-by: Jonathan Cubides <jonathan.cubides@uib.no>
2023-05-15 14:02:09 +03:00
$(mkRelDir ".")
$(mkRelFile "test052.juvix")
Inlining (#2036) * Closes #1989 * Adds optimization phases to the pipline (specified by `opt-phase-eval`, `opt-phase-exec` and `opt-phase-geb` transformations). * Adds the `-O` option to the `compile` command to specify the optimization level. * Functions can be declared for inlining with the `inline` pragma: ``` {-# inline: true #-} const : {A B : Type} -> A -> B -> A; const x _ := x; ``` By default, the function is inlined only if it's fully applied. One can specify that a function (partially) applied to at least `n` explicit arguments should be inlined. ``` {-# inline: 2 #-} compose : {A B C : Type} -> (B -> C) -> (A -> B) -> A -> C; compose f g x := f (g x); ``` Then `compose f g` will be inlined, even though it's not fully applied. But `compose f` won't be inlined. * Non-recursive fully applied functions are automatically inlined if the height of the body term does not exceed the inlining depth limit, which can be specified with the `--inline` option to the `compile` command. * The pragma `inline: false` disables automatic inlining on a per-function basis.
2023-05-15 18:27:05 +03:00
$(mkRelFile "out/test052.out"),
posTest
"Test053: Inlining"
$(mkRelDir ".")
$(mkRelFile "test053.juvix")
Iterator syntax (#2126) * Closes #1992 A function identifier `fun` can be declared as an iterator with ``` syntax iterator fun; ``` For example: ```haskell syntax iterator for; for : {A B : Type} -> (A -> B -> A) -> A -> List B -> List A; for f acc nil := acc; for f acc (x :: xs) := for (f acc x) xs; ``` Iterator application syntax allows for a finite number of initializers `acc := a` followed by a finite number of ranges `x in xs`. For example: ``` for (acc := 0) (x in lst) acc + x ``` The number of initializers plus the number of ranges must be non-zero. An iterator application ``` fun (acc1 := a1; ..; accn := an) (x1 in b1; ..; xk in bk) body ``` gets desugared to ``` fun \{acc1 .. accn x1 .. xk := body} a1 .. an b1 .. bk ``` The `acc1`, ..., `accn`, `x1`, ..., `xk` can be patterns. The desugaring works on a purely syntactic level. Without further restrictions, it is not checked if the number of initializers/ranges matches the type of the identifier. The restrictions on the number of initializers/ranges can be specified in iterator declaration: ``` syntax iterator fun {init: n, range: k}; syntax iterator for {init: 1, range: 1}; syntax iterator map {init: 0, range: 1}; ``` The attributes (`init`, `range`) in between braces are parsed as YAML to avoid inventing and parsing a new attribute language. Both attributes are optional.
2023-05-30 16:30:11 +03:00
$(mkRelFile "out/test053.out"),
posTest
"Test054: Iterators"
$(mkRelDir ".")
$(mkRelFile "test054.juvix")
Respect fixity in runtime printer (#2182) * Closes #2180
2023-06-07 12:44:41 +03:00
$(mkRelFile "out/test054.out"),
posTest
"Test055: Constructor printing"
$(mkRelDir ".")
$(mkRelFile "test055.juvix")
Specialization optimisation (#2164) * Closes #2147 Adds a `specialize` pragma which allows to specify (explicit) arguments considered for specialization. Whenever a function is applied to a constant known value for the specialized argument, a new version of the function will be created with the argument pasted in. For example, the code ```juvix {-# specialize: [1] #-} mymap : {A B : Type} -> (A -> B) -> List A -> List B; mymap f nil := nil; mymap f (x :: xs) := f x :: mymap f xs; main : Nat; main := length (mymap λ{x := x + 3} (1 :: 2 :: 3 :: 4 :: nil)); ``` will be transformed into code equivalent to ```juvix mymap' : (Nat -> Nat) -> List Nat -> List Nat; mymap' f nil := nil; mymap' f (x :: xs) := λ{x := x + 3} x :: mymap' xs; main : Nat; main := length (mymap' (1 :: 2 :: 3 :: 4 :: nil)); ```
2023-06-26 17:49:19 +03:00
$(mkRelFile "out/test055.out"),
posTest
"Test056: Argument specialization"
$(mkRelDir ".")
$(mkRelFile "test056.juvix")
Case folding (#2229) Fold constant cases, i.e., convert ``` case C a b | A := .. | B x := .. | C x y := M ``` to ``` let x := a; y := b; in M ```
2023-06-27 13:29:26 +03:00
$(mkRelFile "out/test056.out"),
posTest
"Test057: Case folding"
$(mkRelDir ".")
$(mkRelFile "test057.juvix")
Numeric range types (#2232) * Closes #2145
2023-06-28 18:24:08 +03:00
$(mkRelFile "out/test057.out"),
posTest
"Test058: Ranges"
$(mkRelDir ".")
$(mkRelFile "test058.juvix")
Add syntax for builtin list (#2239) - Depends on #2219 - Closes #1643 This pr introduces a `list` as a new builtin so that we can use syntax sugar both in expressions and patterns. E.g. it is now possible to write `[1; 2; 3;]`.
2023-07-03 14:24:56 +03:00
$(mkRelFile "out/test058.out"),
posTest
"Test059: Builtin list"
$(mkRelDir ".")
$(mkRelFile "test059.juvix")
Record updates (#2263) - Closes #1642. This pr introduces syntax for convenient record updates. Example: ``` type Triple (A B C : Type) := | mkTriple { fst : A; snd : B; thd : C; }; main : Triple Nat Nat Nat; main := let p : Triple Nat Nat Nat := mkTriple 2 2 2; p' : Triple Nat Nat Nat := p @Triple{ fst := fst + 1; snd := snd * 3 }; f : Triple Nat Nat Nat -> Triple Nat Nat Nat := (@Triple{fst := fst * 10}); in f p'; ``` We write `@InductiveType{..}` to update the contents of a record. The `@` is used for parsing. The `InductiveType` symbol indicates the type of the record update. Inside the braces we have a list of `fieldName := newValue` items separated by semicolon. The `fieldName` is bound in `newValue` with the old value of the field. Thus, we can write something like `p @Triple{fst := fst + 1;}`. Record updates `X@{..}` are parsed as postfix operators with higher priority than application, so `f x y @X{q := 1}` is equivalent to `f x (y @X{q := 1})`. It is possible the use a record update with no argument by wrapping the update in parentheses. See `f` in the above example.
2023-08-07 13:35:36 +03:00
$(mkRelFile "out/test059.out"),
posTest
"Test060: Record update"
$(mkRelDir ".")
$(mkRelFile "test060.juvix")
Traits (#2320) * Closes #1646 Implements a basic trait framework. A simple instance search mechanism is included which fails if there is more than one matching instance at any step. Example usage: ``` import Stdlib.Prelude open hiding {Show; mkShow; show}; trait type Show A := mkShow { show : A → String }; instance showStringI : Show String := mkShow (show := id); instance showBoolI : Show Bool := mkShow (show := λ{x := if x "true" "false"}); instance showNatI : Show Nat := mkShow (show := natToString); showList {A} : {{Show A}} → List A → String | nil := "nil" | (h :: t) := Show.show h ++str " :: " ++str showList t; instance showListI {A} {{Show A}} : Show (List A) := mkShow (show := showList); showMaybe {A} {{Show A}} : Maybe A → String | (just x) := "just (" ++str Show.show x ++str ")" | nothing := "nothing"; instance showMaybeI {A} {{Show A}} : Show (Maybe A) := mkShow (show := showMaybe); main : IO := printStringLn (Show.show true) >> printStringLn (Show.show false) >> printStringLn (Show.show 3) >> printStringLn (Show.show [true; false]) >> printStringLn (Show.show [1; 2; 3]) >> printStringLn (Show.show [1; 2]) >> printStringLn (Show.show [true; false]) >> printStringLn (Show.show [just true; nothing; just false]) >> printStringLn (Show.show [just [1]; nothing; just [2; 3]]) >> printStringLn (Show.show "abba") >> printStringLn (Show.show ["a"; "b"; "c"; "d"]); ``` It is possible to manually provide an instance and to match on implicit instances: ``` f {A} : {{Show A}} -> A -> String | {{mkShow s}} x -> s x; f' {A} : {{Show A}} → A → String | {{M}} x := Show.show {{M}} x; ``` The trait parameters in instance types are checked to be structurally decreasing to avoid looping in the instance search. So the following is rejected: ``` type Box A := box A; trait type T A := mkT { pp : A → A }; instance boxT {A} : {{T (Box A)}} → T (Box A) := mkT (λ{x := x}); ``` We check whether each parameter is a strict subterm of some trait parameter in the target. This ordering is included in the finite multiset extension of the subterm ordering, hence terminating.
2023-09-08 13:16:43 +03:00
$(mkRelFile "out/test060.out"),
posTest
"Test061: Traits"
$(mkRelDir ".")
$(mkRelFile "test061.juvix")
Improve closure calls in the runtime (#2396) * Closes #1653 The running time improvement is 20-30% on benchmarks dominated by closure calls.
2023-09-29 15:20:00 +03:00
$(mkRelFile "out/test061.out"),
posTest
"Test062: Overapplication"
$(mkRelDir ".")
$(mkRelFile "test062.juvix")
$(mkRelFile "out/test062.out")
Tests for the new compilation pipeline (#1703) Adds Juvix tests for the compilation pipeline - these are converted from the JuvixCore tests (those that make sense). Currently, only the translation from Juvix to JuvixCore is checked for the tests that can be type-checked. Ultimately, the entire compilation pipeline down to native code / WebAssembly should be checked on these tests. Closes #1689
2023-01-12 13:22:32 +03:00
]
Reference in New Issue Copy Permalink