mirror of
https://github.com/CatalaLang/catala.git
synced 2024-09-19 16:28:12 +03:00
b9156bb60e
Previously we had some heuristics in the backends trying to achieve this with a lot of holes ; this should be much more solid, relying on `Bindlib` to do the correct renamings. **Note1**: it's not plugged into the backends other than OCaml at the moment. **Note2**: the related, obsolete heuristics haven't been cleaned out yet **Note3**: we conservatively suppose a single namespace at the moment. This is required for e.g. Python, but it forces vars named like struct fields to be renamed, which is more verbose in e.g. OCaml. The renaming engine could be improved to support different namespaces, with a way to select how to route the different kinds of identifiers into them. Similarly, customisation for what needs to be uppercase or lowercase is not available yet. **Note4**: besides excluding keywords, we should also be careful to exclude (or namespace): - the idents used in the runtime (e.g. `o_add_int_int`) - the dynamically generated idents (e.g. `embed_*`) **Note5**: module names themselves aren't handled yet. The reason is that they must be discoverable by the user, and even need to match the filenames, etc. In other words, imagine that `Mod` is a keyword in the target language. You can't rename a module called `Mod` to `Mod1` without knowing the whole module context, because that would destroy the mapping for a module already called `Mod1`. A reliable solution would be to translate all module names to e.g. `CatalaModule_*`, which we can assume will never conflict with any built-in, and forbid idents starting with that prefix. We may also want to restrict their names to ASCII ? Currently we use a projection, but what if I have two modules called `Là` and `La` ?
126 lines
3.9 KiB
OCaml
126 lines
3.9 KiB
OCaml
(* This file is part of the Catala compiler, a specification language for tax
|
|
and social benefits computation rules. Copyright (C) 2020-2022 Inria,
|
|
contributor: Louis Gesbert <louis.gesbert@inria.fr>
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
use this file except in compliance with the License. You may obtain a copy of
|
|
the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
License for the specific language governing permissions and limitations under
|
|
the License. *)
|
|
|
|
open Definitions
|
|
|
|
type ('e, 'elt, 'last) t = ('e, 'elt, 'last) bound_list =
|
|
| Last of 'last
|
|
| Cons of 'elt * ('e, ('e, 'elt, 'last) t) binder
|
|
|
|
let rec to_seq = function
|
|
| Last _ -> Seq.empty
|
|
| Cons (item, next_bind) ->
|
|
fun () ->
|
|
let v, next = Bindlib.unbind next_bind in
|
|
Seq.Cons ((v, item), to_seq next)
|
|
|
|
let rec last = function
|
|
| Last e -> e
|
|
| Cons (_, bnd) ->
|
|
let _, next = Bindlib.unbind bnd in
|
|
last next
|
|
|
|
let rec iter ~f = function
|
|
| Last l -> l
|
|
| Cons (item, next_bind) ->
|
|
let var, next = Bindlib.unbind next_bind in
|
|
f var item;
|
|
iter ~f next
|
|
|
|
let rec find ~f = function
|
|
| Last _ -> raise Not_found
|
|
| Cons (item, next_bind) -> (
|
|
match f item with
|
|
| Some r -> r
|
|
| None ->
|
|
let _, next = Bindlib.unbind next_bind in
|
|
find ~f next)
|
|
|
|
let rec fold_left ~f ~init = function
|
|
| Last l -> init, l
|
|
| Cons (item, next_bind) ->
|
|
let var, next = Bindlib.unbind next_bind in
|
|
fold_left ~f ~init:(f init item var) next
|
|
|
|
let rec fold_right ~f ~init = function
|
|
| Last l -> init l
|
|
| Cons (item, next_bind) ->
|
|
let var_next, next = Bindlib.unbind next_bind in
|
|
let result_next = fold_right ~f ~init next in
|
|
f item var_next result_next
|
|
|
|
let rec fold_lr ~top ~down ~bottom ~up = function
|
|
| Last l -> bottom l top
|
|
| Cons (item, next_bind) ->
|
|
let var, next = Bindlib.unbind next_bind in
|
|
let top = down var item top in
|
|
let bottom = fold_lr ~down ~up ~top ~bottom next in
|
|
up var item bottom
|
|
|
|
let rec map ~f ~last = function
|
|
| Last l -> Bindlib.box_apply (fun l -> Last l) (last l)
|
|
| Cons (item, next_bind) ->
|
|
let var, next = Bindlib.unbind next_bind in
|
|
let var, item = f var item in
|
|
let next_bind = Bindlib.bind_var var (map ~f ~last next) in
|
|
Bindlib.box_apply2
|
|
(fun item next_bind -> Cons (item, next_bind))
|
|
item next_bind
|
|
|
|
let rec fold_map ~f ~last ~init:ctx = function
|
|
| Last l ->
|
|
let ret, l = last ctx l in
|
|
ret, Bindlib.box_apply (fun l -> Last l) l
|
|
| Cons (item, next_bind) ->
|
|
let var, next = Bindlib.unbind next_bind in
|
|
let ctx, var, item = f ctx var item in
|
|
let ctx, next = fold_map ~f ~last ~init:ctx next in
|
|
let next_bind = Bindlib.bind_var var next in
|
|
( ctx,
|
|
Bindlib.box_apply2
|
|
(fun item next_bind -> Cons (item, next_bind))
|
|
item next_bind )
|
|
|
|
let rec fold_left2 ~f ~init a b =
|
|
match a, b with
|
|
| Last l1, Last l2 -> init, (l1, l2)
|
|
| Cons (item1, next_bind1), Cons (item2, next_bind2) ->
|
|
let var, next1, next2 = Bindlib.unbind2 next_bind1 next_bind2 in
|
|
fold_left2 ~f ~init:(f init item1 item2 var) next1 next2
|
|
| _ -> invalid_arg "fold_left2"
|
|
|
|
let rec equal ~f ~last a b =
|
|
match a, b with
|
|
| Last l1, Last l2 -> last l1 l2
|
|
| Cons (item1, next_bind1), Cons (item2, next_bind2) ->
|
|
f item1 item2
|
|
&&
|
|
let _, next1, next2 = Bindlib.unbind2 next_bind1 next_bind2 in
|
|
equal ~f ~last next1 next2
|
|
| _ -> false
|
|
|
|
let rec compare ~f ~last a b =
|
|
match a, b with
|
|
| Last l1, Last l2 -> last l1 l2
|
|
| Cons (item1, next_bind1), Cons (item2, next_bind2) -> (
|
|
match f item1 item2 with
|
|
| 0 ->
|
|
let _, next1, next2 = Bindlib.unbind2 next_bind1 next_bind2 in
|
|
compare ~f ~last next1 next2
|
|
| n -> n)
|
|
| Last _, Cons _ -> -1
|
|
| Cons _, Last _ -> 1
|