GaloisInc/cryptol
1
1
Fork 0
mirror of https://github.com/GaloisInc/cryptol.git synced 2024-12-18 21:41:52 +03:00
Code Issues Projects Releases Wiki Activity
ec7c9a0f6e
cryptol/tests/mono-binds/test05.icry.stdout

84 lines
3.0 KiB
Plaintext
Raw Normal View History

Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
Loading module Cryptol
Loading module Cryptol
Loading module test05
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
[warning] at ./test05.cry:9:3--9:6
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
This binding for foo shadows the existing binding from
Update tests and output
2015-09-29 07:26:26 +03:00
(at ./test05.cry:4:1--4:4, foo)
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
[warning] at ./test05.cry:13:5--13:8
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
This binding for foo shadows the existing binding from
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
(at ./test05.cry:9:3--9:6, foo)
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
module test05
import Cryptol
/* Not recursive */
test05::foo : [10]
Rename primitive `demote` to the more self-explanatory name `number`. The name "demote" is only meaningful to those who already know what the Cryptol primitive does. Also, due to recent changes in the error and warning messages, the name "demote" is showing up much more often in REPL output. For example: Defaulting type argument 'rep' of 'demote' to [2] Showing a specific instance of polymorphic result: * Using 'Integer' for type argument 'rep' of 'Cryptol::demote' These messages will hopefully be made less confusing to non-experts if the name "demote" is replaced with "number".
2018-07-27 23:52:57 +03:00
test05::foo = Cryptol::number 10 [10] <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::test : {n, a, b} (Zero b, Literal 10 a) => [n]b -> a
test05::test = \{n, a, b} (Zero b, Literal 10 a) (a : [n]b) ->
Cryptol::number 10 a <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
where
/* Not recursive */
Update tests and output
2015-09-29 07:26:26 +03:00
test05::foo : [10]
Rename primitive `demote` to the more self-explanatory name `number`. The name "demote" is only meaningful to those who already know what the Cryptol primitive does. Also, due to recent changes in the error and warning messages, the name "demote" is showing up much more often in REPL output. For example: Defaulting type argument 'rep' of 'demote' to [2] Showing a specific instance of polymorphic result: * Using 'Integer' for type argument 'rep' of 'Cryptol::demote' These messages will hopefully be made less confusing to non-experts if the name "demote" is replaced with "number".
2018-07-27 23:52:57 +03:00
test05::foo = Cryptol::number 10 [10] <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::f : {m} (fin m) => [n + m]b
Improvements to naming of variables. This does a bunch of small changes, that should improve the usability of Cryptol. Namely: * When we are forced to make up a name, pick something derived from the source of the variable, annotated with the unique. * When pretty printing a schema, use "n,m,i,j,k" for numeric variables and "a,b,c,d,e" for value type vairable. * When generalizing, put numeric vairables first.
2018-06-29 01:58:11 +03:00
test05::f = \{m} (fin m) ->
test05::bar m <>
Update tests and output
2015-09-29 07:26:26 +03:00
where
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::foo : [n]b
Update tests and output
2015-09-29 07:26:26 +03:00
test05::foo = a
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::bar : {i} (fin i) => [i + n]b
Improvements to naming of variables. This does a bunch of small changes, that should improve the usability of Cryptol. Namely: * When we are forced to make up a name, pick something derived from the source of the variable, annotated with the unique. * When pretty printing a schema, use "n,m,i,j,k" for numeric variables and "a,b,c,d,e" for value type vairable. * When generalizing, put numeric vairables first.
2018-06-29 01:58:11 +03:00
test05::bar = \{i} (fin i) ->
Update changed test output.
2018-12-12 02:52:19 +03:00
(Cryptol::#) i n b <> (Cryptol::zero ([i]b) <>) test05::foo
Update tests and output
2015-09-29 07:26:26 +03:00
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
Loading module Cryptol
Loading module test05
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
[warning] at ./test05.cry:9:3--9:6
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
This binding for foo shadows the existing binding from
Name changes in debug output
2015-06-10 00:27:43 +03:00
(at ./test05.cry:4:1--4:4, foo)
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
[warning] at ./test05.cry:13:5--13:8
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
This binding for foo shadows the existing binding from
add load targets to search path Fixes a bug pointed out by @weaversa: https://github.com/GaloisInc/cryptol/issues/127#issuecomment-64464455 In addition to the other search path changes in #127, we now will add the directory containing files to be loaded to the search path. This applies to: - files loaded with a command line argument, like in the original comment - arguments to `:l`, so for example `:l examples/DES.cry` would work - batch file arguments, so for example running `cryptol -b /some/path/bar.cry` adds `/some/path` to the search path.
2015-02-18 02:27:59 +03:00
(at ./test05.cry:9:3--9:6, foo)
Improved locations for defaulting warnings.
2018-06-20 03:28:59 +03:00
[warning] at ./test05.cry:14:11--14:21:
Improve various defaulting/instantiatiation warnings and error messages.
2018-06-26 02:48:10 +03:00
Defaulting type argument 'front' of '(#)' to 0
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
module test05
import Cryptol
/* Not recursive */
test05::foo : [10]
Rename primitive `demote` to the more self-explanatory name `number`. The name "demote" is only meaningful to those who already know what the Cryptol primitive does. Also, due to recent changes in the error and warning messages, the name "demote" is showing up much more often in REPL output. For example: Defaulting type argument 'rep' of 'demote' to [2] Showing a specific instance of polymorphic result: * Using 'Integer' for type argument 'rep' of 'Cryptol::demote' These messages will hopefully be made less confusing to non-experts if the name "demote" is replaced with "number".
2018-07-27 23:52:57 +03:00
test05::foo = Cryptol::number 10 [10] <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::test : {n, a, b} (Zero b, Literal 10 a) => [n]b -> a
test05::test = \{n, a, b} (Zero b, Literal 10 a) (a : [n]b) ->
Cryptol::number 10 a <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
where
/* Not recursive */
Update tests and output
2015-09-29 07:26:26 +03:00
test05::foo : [10]
Rename primitive `demote` to the more self-explanatory name `number`. The name "demote" is only meaningful to those who already know what the Cryptol primitive does. Also, due to recent changes in the error and warning messages, the name "demote" is showing up much more often in REPL output. For example: Defaulting type argument 'rep' of 'demote' to [2] Showing a specific instance of polymorphic result: * Using 'Integer' for type argument 'rep' of 'Cryptol::demote' These messages will hopefully be made less confusing to non-experts if the name "demote" is replaced with "number".
2018-07-27 23:52:57 +03:00
test05::foo = Cryptol::number 10 [10] <>
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::f : [n]b
Update tests and output
2015-09-29 07:26:26 +03:00
test05::f = test05::bar
where
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::foo : [n]b
Update tests and output
2015-09-29 07:26:26 +03:00
test05::foo = a
/* Not recursive */
Update changed test output.
2018-12-12 02:52:19 +03:00
test05::bar : [n]b
test05::bar = (Cryptol::#) 0 n b <> (Cryptol::zero ([0]b) <>) test05::foo
Update tests and output
2015-09-29 07:26:26 +03:00
Add the mono-binds flag When `:set mono-binds=on`, any local definitions lacking type signatures will not be generalized (i.e., will be monomorphic). This reduces what is in most cases unnecessary polymorphism that can give rise to constraints that are difficult to solve. This also improves the performance of the Cryptol interpreter by lifting many polymorphic type applications out of the inner loops that are commonly defined as bindings in `where` clauses. The flag is on by default in the Cryptol REPL, and in most cases makes it possible to leave out more type signatures in `where` clauses than before. However, some programs really do rely on inferring polymorphic types for local variables; in this case adding an explicit polymorphic type signature to the local binding in question will make the program typecheck.
2014-12-16 04:48:25 +03:00
Reference in New Issue Copy Permalink