balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'api-docs/big_map' into 'dev'

Browse Source 
Add syntax specific titles to Big_map

See merge request ligolang/ligo!493
This commit is contained in:
Sander 2020-03-12 13:05:00 +00:00
commit f176d36dd8
20 changed files with 4162 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gitlab-pages/docker-compose.yml
View File

@ -17,7 +17,7 @@ services:
# - ./website/versioned_docs:/app/website/versioned_docs
- ./website/sidebars.json:/app/website/sidebars.json
- ./website/docusaurus.config.js:/app/website/docusaurus.config.js
- ./website/versions.json:/app/website/versions.json
# - ./website/versions.json:/app/website/versions.json
# - ./website/core/AlgoliaSearch.js:/app/website/core/AlgoliaSearch.js
working_dir: /app/website

243
gitlab-pages/docs/reference/big_map.md
View File

@ -1,25 +1,36 @@
---
id: big-map-reference
title: Big Maps — Scalable Maps
title: Big_map
description: A lazily deserialized map that's intended to store large amounts of data.
hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
Ordinary maps are fine for contracts with a finite lifespan or a
bounded number of users. For many contracts however, the intention is
to have a map holding *many* entries, potentially millions of
them. The cost of loading those entries into the environment each time
a user executes the contract would eventually become too expensive
were it not for *big maps*. Big maps are a data structure offered by
Michelson which handles the scaling concerns for us. In LIGO, the
interface for big maps is analogous to the one used for ordinary maps.
A lazily deserialized map that's intended to store large amounts of data.
# Declaring a Map
The gast costs of deserialized maps are higher than standard maps as data is lazily deserialized.
<SyntaxTitle syntax="pascaligo">
type big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type big_map ('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
The type of a big map from values of type `key` to
values of type `value` is `big_map (key, value)`.
```pascaligo group=big_map
type move is int * int
type register is big_map (address, move)
```
@ -27,67 +38,101 @@ type register is big_map (address, move)
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
The type of a big map from values of type `key` to values
of type `value` is `(key, value) big_map`.
```cameligo group=big_map
type move = int * int
type register = (address, move) big_map
```
</Syntax>
<Syntax syntax="reasonligo">
The type of a big map from values of type `key` to
values of type `value` is `big_map (key, value)`.
```reasonligo group=big_maps
```reasonligo group=big_map
type move = (int, int);
type register = big_map (address, move);
```
</Syntax>
<SyntaxTitle syntax="pascaligo">
function empty : big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val empty : ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let empty: big_map ('key, 'value)
</SyntaxTitle>
# Creating an Empty Big Map
Create an empty big_map.
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
const empty : register = big_map []
```pascaligo group=big_map
const empty : register = Big_map.empty
```
Alternatively, you can also create an empty big_map using:
```pascaligo group=big_map
const empty_alternative : register = big_map []
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
```cameligo group=big_map
let empty : register = Big_map.empty
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_maps
```reasonligo group=big_map
let empty : register = Big_map.empty
```
</Syntax>
# Creating a Non-empty Map
<SyntaxTitle syntax="pascaligo">
function literal : list (key * value) -> big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val literal : ('key * 'value) list -> ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let literal: list(('key, 'value)) => big_map('key, 'value)
</SyntaxTitle>
Create a non-empty big_map.
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
```pascaligo group=big_map
const moves : register =
Big_map.literal (list [
(("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address), (1,2));
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (0,3))]);
```
Alternative way of creating an empty big_map:
```pascaligo group=big_map
const moves_alternative : register =
big_map [
("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address) -> (1,2);
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)]
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)];
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
```cameligo group=big_map
let moves : register =
Big_map.literal [
(("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address), (1,2));
@ -97,7 +142,7 @@ let moves : register =
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_maps
```reasonligo group=big_map
let moves : register =
Big_map.literal ([
("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address, (1,2)),
@ -106,21 +151,40 @@ let moves : register =
</Syntax>
<SyntaxTitle syntax="pascaligo">
function find_opt : key -> big_map (key, value) -> option value
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val find_opt : 'key -> ('key, 'value) big_map -> 'value option
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let find_opt : ('key, big_map ('key, 'value)) => option ('value)
</SyntaxTitle>
# Accessing Values
Retrieve a value from a big map with the given key.
Because the key may be missing in the big map, the result is an
*optional value*.
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
```pascaligo group=big_map
const my_balance : option (move) =
moves [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address)]
Big_map.find_opt (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), moves)
```
Alternatively:
```pascaligo group=big_map
const my_balance_alternative : option (move) =
moves [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address)];
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
```cameligo group=big_map
let my_balance : move option =
Big_map.find_opt ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) moves
```
@ -128,33 +192,62 @@ let my_balance : move option =
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_maps
```reasonligo group=big_map
let my_balance : option (move) =
Big_map.find_opt ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address, moves);
```
</Syntax>
<SyntaxTitle syntax="pascaligo">
function update : key -> option value -> big_map (key, value) -> big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val update: 'key -> 'value option -> ('key, 'value) big_map -> ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let update: ('key, option('value), big_map ('key, 'value)) => big_map ('key, 'value)
</SyntaxTitle>
# Updating Big Maps
Note: when `None` is used as a value, the value is removed from the big_map.
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
function add (var m : register) : register is
block {
m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9)
} with m
const updated_map : register = add (moves)
```pascaligo group=big_map
const updated_big_map : register = Big_map.update(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some (4,9), moves);
```
Alternatively:
```pascaligo group=big_map
function update (var m : register) : register is
block {
m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9);
} with m
```
If multiple bindings need to be updated, PascaLIGO offers a *patch
instruction* for maps, similar to that for records.
```pascaligo group=big_map
function assignments (var m : register) : register is
block {
patch m with map [
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (4,9);
("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address) -> (1,2)
]
} with m
```
> Note the use of the keyword `map` instead of `big_map` (which is not
> a keyword).
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
```cameligo group=big_map
let updated_map : register =
Big_map.update
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) (Some (4,9)) moves
@ -163,7 +256,7 @@ let updated_map : register =
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_maps
```reasonligo group=big_map
let updated_map : register =
Big_map.update
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some ((4,9)), moves);
@ -171,14 +264,64 @@ let updated_map : register =
</Syntax>
<SyntaxTitle syntax="pascaligo">
function add : key -> value -> big_map (key, value) -> big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val add : 'key -> 'value -> ('key, 'value) big_map -> ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let add: ('key, 'value, big_map('key, 'value)) => big_map('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo">
# Removing Bindings
```pascaligo group=big_map
const added_item : register = Big_map.add (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4, 9), moves)
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_map
let add (m : register) : register =
Big_map.add
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) (4,9) m
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_map
let add = (m: register): register =>
Big_map.add
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4,9), m);
```
</Syntax>
<SyntaxTitle syntax="pascaligo">
function remove: key -> big_map (key, value) -> big_map (key, value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val remove: 'key -> ('key, 'value) big_map -> ('key, 'value) big_map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let remove: (key, big_map ('key, 'value)) => big_map ('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo">
```pascaligo group=big_maps
```pascaligo group=big_map
const updated_map : register =
Big_map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
```
Alternatively, the instruction `remove key from map m` removes the key
`key` from the big map `m` (note that the keyword is `map`, not
`big_map`).
```pascaligo group=big_map
function rem (var m : register) : register is
block {
remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) from map moves
@ -190,17 +333,17 @@ const updated_map : register = rem (moves)
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=big_maps
```cameligo group=big_map
let updated_map : register =
Map.remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves
Big_map.remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=big_maps
```reasonligo group=big_map
let updated_map : register =
Map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
Big_map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
```
</Syntax>

8
gitlab-pages/website/docusaurus.config.js
View File

@ -99,7 +99,6 @@ const siteConfig = {
},*/
// Add custom scripts here that would be placed in <script> tags.
scripts: ['https://buttons.github.io/buttons.js'],
// On page navigation for the current documentation page.
// No .html extensions for paths.
@ -113,11 +112,12 @@ const siteConfig = {
// You may provide arbitrary config keys to be used as needed by your
// template. For example, if you need your repo's URL...
// repoUrl: repoUrl,
stylesheets: [
'https://fonts.googleapis.com/css?family=DM+Sans:400,400i,500,500i,700,700i|Open+Sans:300,300i,400,600|Source+Code+Pro&display=swap'
plugins: [
'@ligo/syntax', {
}
],
presets: [
[
'@docusaurus/preset-classic',

9
gitlab-pages/website/package.json
View File

@ -14,11 +14,18 @@
"webpack": "4.41.2"
},
"browserslist": {
"production": [">0.2%", "not dead", "not op_mini all"],
"production": [
">0.2%",
"not dead",
"not op_mini all"
],
"development": [
"last 1 chrome version",
"last 1 firefox version",
"last 1 safari version"
]
},
"dependencies": {
"@ligo/syntax": "file:src/@ligo/syntax"
}
}

12
gitlab-pages/website/src/@ligo/syntax/output/index.js Normal file
View File

@ -0,0 +1,12 @@
const path = require('path');
module.exports = function (context, options) {
return {
name: 'ligo-syntax-plugin',
getThemePath() {
return path.resolve(__dirname, './theme');
}
};
};

3
gitlab-pages/website/src/@ligo/syntax/output/theme/Syntax/SyntaxContext.js Normal file
View File

@ -0,0 +1,3 @@
import React from 'react';
const SyntaxContext = React.createContext('pascaligo');
export default SyntaxContext;

18
gitlab-pages/website/src/@ligo/syntax/output/theme/Syntax/SyntaxSwitch.js Normal file
View File

@ -0,0 +1,18 @@
import React from 'react';
import styles from './styles.module.css';
function SyntaxSwitch(props) {
return React.createElement("select", {
className: styles.syntaxSwitch,
defaultValue: props.syntax,
onChange: e => props.onSyntaxChange(e.target.value)
}, React.createElement("option", {
value: "pascaligo"
}, "PascaLIGO"), React.createElement("option", {
value: "cameligo"
}, "CameLIGO"), React.createElement("option", {
value: "reasonligo"
}, "ReasonLIGO"));
}
export default SyntaxSwitch;

15
gitlab-pages/website/src/@ligo/syntax/output/theme/Syntax/index.js Normal file
View File

@ -0,0 +1,15 @@
import React from 'react';
import SyntaxContext from './SyntaxContext';
function Syntax(props) {
return React.createElement(SyntaxContext.Consumer, null, syntax => {
if (syntax === props.syntax) {
return props.children;
} else {
return React.createElement(React.Fragment, null);
}
});
}
export default Syntax;
export { SyntaxContext };

0
gitlab-pages/website/src/theme/Syntax/styles.module.css → gitlab-pages/website/src/@ligo/syntax/output/theme/Syntax/styles.module.css
View File

111
gitlab-pages/website/src/@ligo/syntax/output/theme/SyntaxTitle/index.js Normal file
View File

@ -0,0 +1,111 @@
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
import React, { useEffect, useState, useRef } from 'react';
import Highlight, { defaultProps } from "prism-react-renderer"; // THE PROBLEM IS USE THEME CONTEXT ==>>>>
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import useThemeContext from '@theme/hooks/useThemeContext';
import { SyntaxContext } from '@theme/Syntax';
import defaultTheme from 'prism-react-renderer/themes/palenight';
const {
Prism
} = require("prism-react-renderer");
Prism.languages = { ...Prism.languages,
pascaligo: {
'comment': [/\(\*[\s\S]+?\*\)/, // /\{[\s\S]+?\}/,
/\/\/.*/],
'string': {
pattern: /(?:'(?:''|[^'\r\n])*'|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
greedy: true
},
'keyword': [{
// Turbo Pascal
pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
lookbehind: true
}, {
// Free Pascal
pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
lookbehind: true
}, {
// Object Pascal
pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
lookbehind: true
}, {
// Modifiers
pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
lookbehind: true
}],
'number': [// Hexadecimal, octal and binary
/(?:[&%]\d+|\$[a-f\d]+)/i, // Decimal
/\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i],
'operator': [/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/i, {
pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
lookbehind: true
}],
'punctuation': /\(\.|\.\)|[()\[\]:;,.]/
},
reasonligo: { ...Prism.languages.reason,
'comment': [/(^|[^\\])\/\*[\s\S]*?\*\//, /\(\*[\s\S]*?\*\)/, /\/\/.*/]
},
cameligo: { ...Prism.languages.ocaml,
'comment': [/(^|[^\\])\/\*[\s\S]*?\*\//, /\(\*[\s\S]*?\*\)/, /\/\/.*/]
}
};
function SyntaxTitle(props) {
const {
siteConfig: {
themeConfig: {
prism = {}
}
}
} = useDocusaurusContext();
const {
isDarkTheme
} = useThemeContext();
const lightModeTheme = prism.theme || defaultTheme;
const darkModeTheme = prism.darkTheme || lightModeTheme;
const prismTheme = isDarkTheme ? darkModeTheme : lightModeTheme;
const [mounted, setMounted] = useState(false);
useEffect(() => {
setMounted(true);
}, []);
return React.createElement(SyntaxContext.Consumer, null, syntax => {
if (syntax === props.syntax) {
return React.createElement(Highlight, _extends({}, defaultProps, {
key: mounted,
language: props.syntax,
code: props.children,
theme: prismTheme
}), ({
className,
style,
tokens,
getLineProps,
getTokenProps
}) => React.createElement("pre", {
className: className,
style: {
backgroundColor: 'var(--ifm-background-color)',
fontSize: '1.1rem',
fontWeight: 'bold',
padding: 0,
whiteSpace: 'break-spaces',
marginTop: '3rem'
}
}, tokens.map((line, i) => React.createElement("div", getLineProps({
line,
key: i
}), line.map((token, key) => React.createElement("span", getTokenProps({
token,
key
})))))));
} else {
return React.createElement("div", null);
}
});
}
export default SyntaxTitle;

3449
gitlab-pages/website/src/@ligo/syntax/package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

28
gitlab-pages/website/src/@ligo/syntax/package.json Normal file
View File

@ -0,0 +1,28 @@
{
"name": "@ligo/syntax",
"description": "Switch between different syntaxes",
"version": "0.0.0",
"main": "output/index.js",
"peerDependencies": {
"@docusaurus/core": "^2.0.0-alpha.43",
"@docusaurus/preset-classic": "^2.0.0-alpha.43",
"react": "^16.8.4",
"react-dom": "^16.8.4",
"webpack": "4.41.2"
},
"devDependencies": {
"@babel/cli": "^7.8.4",
"@babel/core": "^7.8.7",
"@babel/preset-env": "^7.8.7",
"@babel/preset-react": "^7.8.3",
"prism-react-renderer": "^1.0.2"
},
"babel": {
"presets": [
"@babel/preset-react"
]
},
"scripts": {
"build": "rm -rf output && mkdir output && node_modules/.bin/babel src/theme/Syntax/*.js -d output/theme/Syntax/ && node_modules/.bin/babel src/theme/SyntaxTitle/*.js -d output/theme/SyntaxTitle/ && node_modules/.bin/babel src/*.js -d output/ && cp ./src/theme/Syntax/styles.module.css output/theme/Syntax/"
}
}

11
gitlab-pages/website/src/@ligo/syntax/src/index.js Normal file
View File

@ -0,0 +1,11 @@
const path = require('path');
module.exports = function(context, options) {
return {
name: 'ligo-syntax-plugin',
getThemePath() {
return path.resolve(__dirname, './theme');
}
}
}

1
gitlab-pages/website/src/theme/Syntax/SyntaxContext.js → gitlab-pages/website/src/@ligo/syntax/src/theme/Syntax/SyntaxContext.js
View File

@ -3,4 +3,3 @@ import React from 'react';
const SyntaxContext = React.createContext('pascaligo');
export default SyntaxContext;

2
gitlab-pages/website/src/theme/Syntax/SyntaxSwitch.js → gitlab-pages/website/src/@ligo/syntax/src/theme/Syntax/SyntaxSwitch.js
View File

@ -2,7 +2,7 @@ import React from 'react';
import styles from './styles.module.css';
function SyntaxSwitch (props) {
function SyntaxSwitch (props) {
return (
<select className={styles.syntaxSwitch} defaultValue={props.syntax} onChange={e => props.onSyntaxChange(e.target.value)}>
<option value="pascaligo">PascaLIGO</option>

2
gitlab-pages/website/src/theme/Syntax/index.js → gitlab-pages/website/src/@ligo/syntax/src/theme/Syntax/index.js
View File

@ -16,3 +16,5 @@ function Syntax(props) {
}
export default Syntax
export { SyntaxContext }

37
gitlab-pages/website/src/@ligo/syntax/src/theme/Syntax/styles.module.css Normal file
View File

@ -0,0 +1,37 @@
.syntaxSwitch {
display: block;
font-size: 1rem;
font-weight: bold;
line-height: 1rem;
padding: .6em 1.4em .5em .8em;
box-sizing: border-box;
border: none;
color: var(--color-primary-text);
-moz-appearance: none;
-webkit-appearance: none;
appearance: none;
background-color: transparent;
background-image: url('data:image/svg+xml;charset=US-ASCII,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22292.4%22%20height%3D%22292.4%22%3E%3Cpath%20fill%3D%22%23007CB2%22%20d%3D%22M287%2069.4a17.6%2017.6%200%200%200-13-5.4H18.4c-5%200-9.3%201.8-12.9%205.4A17.6%2017.6%200%200%200%200%2082.2c0%205%201.8%209.3%205.4%2012.9l128%20127.9c3.6%203.6%207.8%205.4%2012.8%205.4s9.2-1.8%2012.8-5.4L287%2095c3.5-3.5%205.4-7.8%205.4-12.8%200-5-1.9-9.2-5.5-12.8z%22%2F%3E%3C%2Fsvg%3E');
background-repeat: no-repeat, repeat;
background-position: right .7em top 50%, 0 0;
background-size: .65em auto, 100%;
}
.syntaxSwitch::-ms-expand {
display: none;
}
.syntaxSwitch:hover {
border-color: #888;
}
.syntaxSwitch:focus {
border-color: #aaa;
box-shadow: 0 0 1px 3px rgba(59, 153, 252, .7);
box-shadow: 0 0 0 3px -moz-mac-focusring;
color: var(--color-primary-text);
outline: none;
}
.syntaxSwitch option {
color: var(--color-primary-text);
font-weight:normal;
}

126
gitlab-pages/website/src/@ligo/syntax/src/theme/SyntaxTitle/index.js Normal file
View File

@ -0,0 +1,126 @@
import React, {useEffect, useState, useRef} from 'react';
import Highlight, { defaultProps } from "prism-react-renderer";
// THE PROBLEM IS USE THEME CONTEXT ==>>>>
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import useThemeContext from '@theme/hooks/useThemeContext';
import { SyntaxContext } from '@theme/Syntax';
import defaultTheme from 'prism-react-renderer/themes/palenight';
const {Prism} = require("prism-react-renderer");
Prism.languages = {
...Prism.languages,
pascaligo: {
'comment': [
/\(\*[\s\S]+?\*\)/,
// /\{[\s\S]+?\}/,
/\/\/.*/
],
'string': {
pattern: /(?:'(?:''|[^'\r\n])*'|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
greedy: true
},
'keyword': [
{
// Turbo Pascal
pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
lookbehind: true
},
{
// Free Pascal
pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
lookbehind: true
},
{
// Object Pascal
pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
lookbehind: true
},
{
// Modifiers
pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
lookbehind: true
}
],
'number': [
// Hexadecimal, octal and binary
/(?:[&%]\d+|\$[a-f\d]+)/i,
// Decimal
/\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i
],
'operator': [
/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/i,
{
pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
lookbehind: true
}
],
'punctuation': /\(\.|\.\)|[()\[\]:;,.]/
},
reasonligo:
{...Prism.languages.reason,
'comment': [
/(^|[^\\])\/\*[\s\S]*?\*\//,
/\(\*[\s\S]*?\*\)/,
/\/\/.*/
]
},
cameligo: {
...Prism.languages.ocaml,
'comment': [
/(^|[^\\])\/\*[\s\S]*?\*\//,
/\(\*[\s\S]*?\*\)/,
/\/\/.*/
]}
};
function SyntaxTitle(props) {
const {
siteConfig: {
themeConfig: {prism = {}},
}
} = useDocusaurusContext();
const {isDarkTheme} = useThemeContext();
const lightModeTheme = prism.theme || defaultTheme;
const darkModeTheme = prism.darkTheme || lightModeTheme;
const prismTheme = isDarkTheme ? darkModeTheme : lightModeTheme;
const [mounted, setMounted] = useState(false);
useEffect(() => {
setMounted(true);
}, []);
return (
<SyntaxContext.Consumer>
{(syntax => {
if (syntax === props.syntax) {
return (
<Highlight {...defaultProps} key={mounted} language={props.syntax} code={props.children} theme={prismTheme}>
{({ className, style, tokens, getLineProps, getTokenProps }) => (
<pre className={className} style={{backgroundColor: 'var(--ifm-background-color)', fontSize: '1.1rem', fontWeight: 'bold', padding: 0, whiteSpace: 'break-spaces', marginTop: '3rem' }}>
{tokens.map((line, i) => (
<div {...getLineProps({ line, key: i })}>
{line.map((token, key) => (
<span {...getTokenProps({ token, key })} />
))}
</div>
))}
</pre>
)}
</Highlight>
)
} else {
return <div></div>
}
})}
</SyntaxContext.Consumer>
);
}
export default SyntaxTitle;

2
gitlab-pages/website/src/theme/DocSidebar/index.js
View File

@ -15,7 +15,7 @@ import isInternalUrl from '@docusaurus/utils'; // eslint-disable-line import/no-
import styles from './styles.module.css';
import SyntaxSwitch from '../Syntax/SyntaxSwitch';
import SyntaxSwitch from '@theme/Syntax/SyntaxSwitch';
const MOBILE_TOGGLE_SIZE = 24;

332
src/passes/operators/operators.ml
View File

@ -62,42 +62,122 @@ module Simplify = struct
| "contract" -> ok @@ TC_contract unit_expr
| _ -> simple_fail @@ "Not a built-in type (" ^ s ^ ")."
let pseudo_modules = function
| "Tezos.chain_id" -> ok C_CHAIN_ID
| "Tezos.balance" -> ok C_BALANCE
| "Tezos.now" -> ok C_NOW
| "Tezos.amount" -> ok C_AMOUNT
| "Tezos.sender" -> ok C_SENDER
| "Tezos.address" -> ok C_ADDRESS
| "Tezos.self" -> ok C_SELF
| "Tezos.self_address" -> ok C_SELF_ADDRESS
| "Tezos.implicit_account" -> ok C_IMPLICIT_ACCOUNT
| "Tezos.source" -> ok C_SOURCE
| "Tezos.failwith" -> ok C_FAILWITH
| "Tezos.create_contract" -> ok C_CREATE_CONTRACT
| "Tezos.transaction" -> ok C_CALL
| "Tezos.set_delegate" -> ok C_SET_DELEGATE
| "Tezos.get_contract_opt" -> ok C_CONTRACT_OPT
| "Tezos.get_entrypoint_opt" -> ok C_CONTRACT_ENTRYPOINT_OPT
(* Crypto module *)
| "Crypto.check" -> ok C_CHECK_SIGNATURE
| "Crypto.hash_key" -> ok C_HASH_KEY
| "Crypto.blake2b" -> ok C_BLAKE2b
| "Crypto.sha256" -> ok C_SHA256
| "Crypto.sha512" -> ok C_SHA512
(* Bytes module *)
| "Bytes.pack" -> ok C_BYTES_PACK
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "Bytes.length" -> ok C_SIZE
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.sub" -> ok C_SLICE
(* List module *)
| "List.length" -> ok C_SIZE
| "List.size" -> ok C_SIZE
| "List.iter" -> ok C_LIST_ITER
| "List.map" -> ok C_LIST_MAP
| "List.fold" -> ok C_LIST_FOLD
(* Set module *)
| "Set.empty" -> ok C_SET_EMPTY
| "Set.literal" -> ok C_SET_LITERAL
| "Set.cardinal" -> ok C_SIZE
| "Set.mem" -> ok C_SET_MEM
| "Set.add" -> ok C_SET_ADD
| "Set.remove" -> ok C_SET_REMOVE
| "Set.iter" -> ok C_SET_ITER
| "Set.fold" -> ok C_SET_FOLD
(* Map module *)
| "Map.find_opt" -> ok C_MAP_FIND_OPT
| "Map.update" -> ok C_MAP_UPDATE
| "Map.iter" -> ok C_MAP_ITER
| "Map.map" -> ok C_MAP_MAP
| "Map.fold" -> ok C_MAP_FOLD
| "Map.mem" -> ok C_MAP_MEM
| "Map.size" -> ok C_SIZE
| "Map.add" -> ok C_MAP_ADD
| "Map.remove" -> ok C_MAP_REMOVE
| "Map.empty" -> ok C_MAP_EMPTY
| "Map.literal" -> ok C_MAP_LITERAL
(* Big_map module *)
| "Big_map.find" -> ok C_MAP_FIND
| "Big_map.find_opt" -> ok C_MAP_FIND_OPT
| "Big_map.update" -> ok C_MAP_UPDATE
| "Big_map.literal" -> ok C_BIG_MAP_LITERAL
| "Big_map.empty" -> ok C_BIG_MAP_EMPTY
| "Big_map.mem" -> ok C_MAP_MEM
| "Big_map.remove" -> ok C_MAP_REMOVE
| "Big_map.add" -> ok C_MAP_ADD
(* Bitwise module *)
| "Bitwise.or" -> ok C_OR
| "Bitwise.and" -> ok C_AND
| "Bitwise.xor" -> ok C_XOR
| "Bitwise.shift_left" -> ok C_LSL
| "Bitwise.shift_right" -> ok C_LSR
(* String module *)
| "String.length" -> ok C_SIZE
| "String.size" -> ok C_SIZE
| "String.slice" -> ok C_SLICE
| "String.sub" -> ok C_SLICE
| "String.concat" -> ok C_CONCAT
| _ -> simple_fail "Not a built-in"
module Pascaligo = struct
let constants = function
(* Tezos module (ex-Michelson) *)
| "Tezos.chain_id" -> ok C_CHAIN_ID
| "chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "get_chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "Tezos.balance" -> ok C_BALANCE
| "balance" -> ok C_BALANCE (* Deprecated *)
| "Tezos.now" -> ok C_NOW
| "get_chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "balance" -> ok C_BALANCE (* Deprecated *)
| "now" -> ok C_NOW (* Deprecated *)
| "Tezos.amount" -> ok C_AMOUNT
| "amount" -> ok C_AMOUNT (* Deprecated *)
| "Tezos.sender" -> ok C_SENDER
| "sender" -> ok C_SENDER (* Deprecated *)
| "Tezos.address" -> ok C_ADDRESS
| "address" -> ok C_ADDRESS (* Deprecated *)
| "Tezos.self" -> ok C_SELF
| "Tezos.self_address" -> ok C_SELF_ADDRESS
| "address" -> ok C_ADDRESS (* Deprecated *)
| "self_address" -> ok C_SELF_ADDRESS (* Deprecated *)
| "Tezos.implicit_account" -> ok C_IMPLICIT_ACCOUNT
| "implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "Tezos.source" -> ok C_SOURCE
| "source" -> ok C_SOURCE (* Deprecated *)
| "Tezos.failwith" -> ok C_FAILWITH
| "implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "source" -> ok C_SOURCE (* Deprecated *)
| "failwith" -> ok C_FAILWITH
| "Tezos.create_contract" -> ok C_CREATE_CONTRACT
| "Tezos.transaction" -> ok C_CALL
| "transaction" -> ok C_CALL (* Deprecated *)
| "Tezos.set_delegate" -> ok C_SET_DELEGATE
| "set_delegate" -> ok C_SET_DELEGATE (* Deprecated *)
| "get_contract" -> ok C_CONTRACT (* Deprecated *)
| "Tezos.get_contract_opt" -> ok C_CONTRACT_OPT
| "get_contract_opt" -> ok C_CONTRACT_OPT (* Deprecated *)
| "get_entrypoint" -> ok C_CONTRACT_ENTRYPOINT (* Deprecated *)
| "Tezos.get_entrypoint_opt" -> ok C_CONTRACT_ENTRYPOINT_OPT
| "get_entrypoint_opt" -> ok C_CONTRACT_ENTRYPOINT_OPT (* Deprecated *)
| "Michelson.is_nat" -> ok C_IS_NAT (* Deprecated *)
@ -126,113 +206,64 @@ module Simplify = struct
(* Crypto module *)
| "Crypto.check" -> ok C_CHECK_SIGNATURE
| "crypto_check" -> ok C_CHECK_SIGNATURE (* Deprecated *)
| "Crypto.hash_key" -> ok C_HASH_KEY
| "crypto_hash_key" -> ok C_HASH_KEY (* Deprecated *)
| "Crypto.blake2b" -> ok C_BLAKE2b
| "blake2b" -> ok C_BLAKE2b (* Deprecated *)
| "Crypto.sha256" -> ok C_SHA256
| "sha_256" -> ok C_SHA256 (* Deprecated *)
| "Crypto.sha512" -> ok C_SHA512
| "crypto_hash_key" -> ok C_HASH_KEY (* Deprecated *)
| "blake2b" -> ok C_BLAKE2b (* Deprecated *)
| "sha_256" -> ok C_SHA256 (* Deprecated *)
| "sha_512" -> ok C_SHA512 (* Deprecated *)
(* Bytes module *)
| "Bytes.pack" -> ok C_BYTES_PACK
| "bytes_pack" -> ok C_BYTES_PACK (* Deprecated *)
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "bytes_unpack" -> ok C_BYTES_UNPACK (* Deprecated *)
| "Bytes.length" -> ok C_SIZE
| "bytes_pack" -> ok C_BYTES_PACK (* Deprecated *)
| "bytes_unpack" -> ok C_BYTES_UNPACK (* Deprecated *)
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "bytes_concat" -> ok C_CONCAT (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE
| "bytes_concat" -> ok C_CONCAT (* Deprecated *)
| "bytes_slice" -> ok C_SLICE (* Deprecated *)
| "Bytes.sub" -> ok C_SLICE
| "Bytes.slice" -> ok C_SLICE (* Deprecated *)
(* List module *)
| "List.length" -> ok C_SIZE
| "List.size" -> ok C_SIZE
| "list_size" -> ok C_SIZE (* Deprecated *)
| "List.iter" -> ok C_LIST_ITER
| "list_iter" -> ok C_LIST_ITER (* Deprecated *)
| "List.map" -> ok C_LIST_MAP
| "list_map" -> ok C_LIST_MAP (* Deprecated *)
| "List.fold" -> ok C_LIST_FOLD
| "list_iter" -> ok C_LIST_ITER (* Deprecated *)
| "list_map" -> ok C_LIST_MAP (* Deprecated *)
| "list_fold" -> ok C_LIST_FOLD (* Deprecated *)
(* Set module *)
| "Set.cardinal" -> ok C_SIZE
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "set_size" -> ok C_SIZE (* Deprecated *)
| "set_empty" -> ok C_SET_EMPTY (* Deprecated *)
| "Set.mem" -> ok C_SET_MEM
| "set_mem" -> ok C_SET_MEM (* Deprecated *)
| "Set.add" -> ok C_SET_ADD
| "set_add" -> ok C_SET_ADD (* Deprecated *)
| "Set.remove" -> ok C_SET_REMOVE
| "set_remove" -> ok C_SET_REMOVE (* Deprecated *)
| "Set.iter" -> ok C_SET_ITER
| "set_iter" -> ok C_SET_ITER (* Deprecated *)
| "Set.fold" -> ok C_SET_FOLD
| "set_empty" -> ok C_SET_EMPTY (* Deprecated *)
| "set_mem" -> ok C_SET_MEM (* Deprecated *)
| "set_add" -> ok C_SET_ADD (* Deprecated *)
| "set_remove" -> ok C_SET_REMOVE (* Deprecated *)
| "set_iter" -> ok C_SET_ITER (* Deprecated *)
| "set_fold" -> ok C_SET_FOLD (* Deprecated *)
(* Map module *)
| "get_force" -> ok C_MAP_FIND (* Deprecated *)
| "map_get" -> ok C_MAP_FIND_OPT (* Deprecated *)
| "Map.find_opt" -> ok C_MAP_FIND_OPT
| "Map.update" -> ok C_MAP_UPDATE
| "map_get" -> ok C_MAP_FIND_OPT (* Deprecated *)
| "map_update" -> ok C_MAP_UPDATE (* Deprecated *)
| "map_remove" -> ok C_MAP_REMOVE (* Deprecated *)
| "Map.iter" -> ok C_MAP_ITER
| "map_iter" -> ok C_MAP_ITER (* Deprecated *)
| "Map.map" -> ok C_MAP_MAP
| "map_map" -> ok C_MAP_MAP (* Deprecated *)
| "Map.fold" -> ok C_MAP_FOLD
| "map_fold" -> ok C_MAP_FOLD (* Deprecated *)
| "Map.mem" -> ok C_MAP_MEM
| "map_mem" -> ok C_MAP_MEM (* Deprecated *)
| "Map.size" -> ok C_SIZE
| "map_remove" -> ok C_MAP_REMOVE (* Deprecated *)
| "map_iter" -> ok C_MAP_ITER (* Deprecated *)
| "map_map" -> ok C_MAP_MAP (* Deprecated *)
| "map_fold" -> ok C_MAP_FOLD (* Deprecated *)
| "map_mem" -> ok C_MAP_MEM (* Deprecated *)
| "map_size" -> ok C_SIZE (* Deprecated *)
(* Big_map module *)
| "Big_map.find_opt" -> ok C_MAP_FIND_OPT
| "Big_map.update" -> ok C_MAP_UPDATE
| "Big_map.literal" -> ok C_BIG_MAP_LITERAL
| "Big_map.empty" -> ok C_BIG_MAP_EMPTY
| "Big_map.size" -> ok C_SIZE
| "Big_map.mem" -> ok C_MAP_MEM
| "Big_map.iter" -> ok C_MAP_ITER
| "Big_map.map" -> ok C_MAP_MAP
| "Big_map.fold" -> ok C_MAP_FOLD
| "Big_map.remove" -> ok C_MAP_REMOVE
(* Bitwise module *)
| "Bitwise.or" -> ok C_OR
| "bitwise_or" -> ok C_OR (* Deprecated *)
| "Bitwise.and" -> ok C_AND
| "bitwise_and" -> ok C_AND (* Deprecated *)
| "Bitwise.xor" -> ok C_XOR
| "bitwise_xor" -> ok C_XOR (* Deprecated *)
| "Bitwise.shift_left" -> ok C_LSL
| "bitwise_lsl" -> ok C_LSL (* Deprecated *)
| "Bitwise.shift_right" -> ok C_LSR
| "bitwise_or" -> ok C_OR (* Deprecated *)
| "bitwise_and" -> ok C_AND (* Deprecated *)
| "bitwise_xor" -> ok C_XOR (* Deprecated *)
| "bitwise_lsl" -> ok C_LSL (* Deprecated *)
| "bitwise_lsr" -> ok C_LSR (* Deprecated *)
(* String module *)
| "String.length" -> ok C_SIZE
| "String.size" -> ok C_SIZE
| "String.slice" -> ok C_SLICE
| "string_slice" -> ok C_SLICE (* Deprecated *)
| "String.sub" -> ok C_SLICE
| "String.concat" -> ok C_CONCAT
| "string_concat" -> ok C_CONCAT (* Deprecated *)
(* Others *)
@ -240,56 +271,41 @@ module Simplify = struct
| "assert" -> ok C_ASSERTION
| "size" -> ok C_SIZE (* Deprecated *)
| _ -> simple_fail "Not a PascaLIGO built-in."
| _ as c ->
pseudo_modules c
let type_constants = type_constants
let type_operators = type_operators
end
module Cameligo = struct
let constants = function
(* Tezos (ex-Michelson, ex-Current, ex-Operation) *)
| "Tezos.chain_id" -> ok C_CHAIN_ID
| "chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "Tezos.balance" -> ok C_BALANCE
| "chain_id" -> ok C_CHAIN_ID (* Deprecated *)
| "Current.balance" -> ok C_BALANCE (* Deprecated *)
| "balance" -> ok C_BALANCE (* Deprecated *)
| "Tezos.now" -> ok C_NOW
| "balance" -> ok C_BALANCE (* Deprecated *)
| "Current.time" -> ok C_NOW (* Deprecated *)
| "time" -> ok C_NOW (* Deprecated *)
| "Tezos.amount" -> ok C_AMOUNT
| "time" -> ok C_NOW (* Deprecated *)
| "Current.amount" -> ok C_AMOUNT (* Deprecated *)
| "amount" -> ok C_AMOUNT (* Deprecated *)
| "Tezos.sender" -> ok C_SENDER
| "amount" -> ok C_AMOUNT (* Deprecated *)
| "Current.sender" -> ok C_SENDER (* Deprecated *)
| "sender" -> ok C_SENDER (* Deprecated *)
| "Tezos.address" -> ok C_ADDRESS
| "Current.address" -> ok C_ADDRESS (* Deprecated *)
| "Tezos.self" -> ok C_SELF
| "Tezos.self_address" -> ok C_SELF_ADDRESS
| "Current.self_address" -> ok C_SELF_ADDRESS (* Deprecated *)
| "Tezos.implicit_account" -> ok C_IMPLICIT_ACCOUNT
| "Current.implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "Tezos.source" -> ok C_SOURCE
| "sender" -> ok C_SENDER (* Deprecated *)
| "Current.address" -> ok C_ADDRESS (* Deprecated *)
| "Current.self_address" -> ok C_SELF_ADDRESS (* Deprecated *)
| "Current.implicit_account" -> ok C_IMPLICIT_ACCOUNT (* Deprecated *)
| "Current.source" -> ok C_SOURCE (* Deprecated *)
| "source" -> ok C_SOURCE (* Deprecated *)
| "Tezos.failwith" -> ok C_FAILWITH
| "source" -> ok C_SOURCE (* Deprecated *)
| "Current.failwith" -> ok C_FAILWITH (* Deprecated *)
| "failwith" -> ok C_FAILWITH
| "Tezos.transaction" -> ok C_CALL
| "Operation.transaction" -> ok C_CALL (* Deprecated *)
| "Tezos.set_delegate" -> ok C_SET_DELEGATE (* Deprecated *)
| "Operation.set_delegate" -> ok C_SET_DELEGATE (* Deprecated *)
| "Operation.get_contract" -> ok C_CONTRACT (* Deprecated *)
| "Tezos.get_contract_opt" -> ok C_CONTRACT_OPT
| "Operation.get_contract_opt" -> ok C_CONTRACT_OPT (* Deprecated *)
| "Operation.get_entrypoint" -> ok C_CONTRACT_ENTRYPOINT (* Deprecated *)
| "Tezos.get_entrypoint_opt" -> ok C_CONTRACT_ENTRYPOINT_OPT
| "Operation.get_entrypoint_opt" -> ok C_CONTRACT_ENTRYPOINT_OPT (* Deprecated *)
| "Tezos.create_contract" -> ok C_CREATE_CONTRACT
| "Michelson.is_nat" -> ok C_IS_NAT (* Deprecated *)
| "is_nat" -> ok C_IS_NAT
@ -314,87 +330,22 @@ module Simplify = struct
| "CONS" -> ok C_CONS
| "NEQ" -> ok C_NEQ
(* Crypto module *)
| "Crypto.check" -> ok C_CHECK_SIGNATURE
| "Crypto.hash_key" -> ok C_HASH_KEY
| "Crypto.blake2b" -> ok C_BLAKE2b
| "Crypto.sha256" -> ok C_SHA256
| "Crypto.sha512" -> ok C_SHA512
(* Bytes module *)
| "Bytes.pack" -> ok C_BYTES_PACK
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "Bytes.length" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE (* Deprecated *)
| "Bytes.sub" -> ok C_SLICE
(* List module *)
| "List.length" -> ok C_SIZE
| "List.size" -> ok C_SIZE
| "List.iter" -> ok C_LIST_ITER
| "List.map" -> ok C_LIST_MAP
| "List.fold" -> ok C_LIST_FOLD
(* Set module *)
| "Set.mem" -> ok C_SET_MEM
| "Set.iter" -> ok C_SET_ITER
| "Set.empty" -> ok C_SET_EMPTY
| "Set.literal" -> ok C_SET_LITERAL
| "Set.add" -> ok C_SET_ADD
| "Set.remove" -> ok C_SET_REMOVE
| "Set.fold" -> ok C_SET_FOLD
(* Set module *)
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "Set.cardinal" -> ok C_SIZE
(* Map module *)
| "Map.find_opt" -> ok C_MAP_FIND_OPT
| "Map.find" -> ok C_MAP_FIND (* Deprecated *)
| "Map.update" -> ok C_MAP_UPDATE
| "Map.add" -> ok C_MAP_ADD
| "Map.remove" -> ok C_MAP_REMOVE
| "Map.iter" -> ok C_MAP_ITER
| "Map.map" -> ok C_MAP_MAP
| "Map.fold" -> ok C_MAP_FOLD
| "Map.mem" -> ok C_MAP_MEM
| "Map.empty" -> ok C_MAP_EMPTY
| "Map.literal" -> ok C_MAP_LITERAL
| "Map.size" -> ok C_SIZE
(* Big_map module *)
| "Big_map.find_opt" -> ok C_MAP_FIND_OPT
| "Big_map.find" -> ok C_MAP_FIND
| "Big_map.update" -> ok C_MAP_UPDATE
| "Big_map.add" -> ok C_MAP_ADD
| "Big_map.remove" -> ok C_MAP_REMOVE
| "Big_map.literal" -> ok C_BIG_MAP_LITERAL
| "Big_map.empty" -> ok C_BIG_MAP_EMPTY
(* Bitwise module *)
| "Bitwise.or" -> ok C_OR
| "Bitwise.lor" -> ok C_OR (* Deprecated *)
| "Bitwise.and" -> ok C_AND
| "Bitwise.land" -> ok C_AND (* Deprecated *)
| "Bitwise.xor" -> ok C_XOR
| "Bitwise.lxor" -> ok C_XOR (* Deprecated *)
| "Bitwise.shift_left" -> ok C_LSL
| "Bitwise.shift_right" -> ok C_LSR
(* String module *)
| "String.length" -> ok C_SIZE
| "String.size" -> ok C_SIZE
| "String.slice" -> ok C_SLICE
| "String.sub" -> ok C_SLICE
| "String.concat" -> ok C_CONCAT
(* Loop module *)
@ -408,7 +359,8 @@ module Simplify = struct
| "assert" -> ok C_ASSERTION
| _ -> simple_fail "Not a CameLIGO built-in."
| _ as c ->
pseudo_modules c
let type_constants = type_constants
let type_operators = type_operators