package catala
Compiler and library for the literate programming language for tax code specification
Install
dune-project
Dependency
Authors
Maintainers
Sources
1.0.0-alpha.tar.gz
md5=2615968670ac21b1d00386a9b04b3843
sha512=eff292fdd75012f26ce7b17020f5a8374eef37cd4dd6ba60338dfbe89fbcad3443d1b409e44c182b740da9f58dff7e76dcb8ddefe47f9b2b160666d1c6930143
doc/src/catala.catala_utils/uid.ml.html
Source file uid.ml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
(* This file is part of the Catala compiler, a specification language for tax and social benefits computation rules. Copyright (C) 2020 Inria, contributor: Denis Merigoux <denis.merigoux@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. *) module type Info = sig type info val to_string : info -> string val format : Format.formatter -> info -> unit val equal : info -> info -> bool val compare : info -> info -> int val hash : info -> Hash.t end module type Id = sig type t type info val fresh : info -> t val get_info : t -> info val map_info : (info -> info) -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val format : Format.formatter -> t -> unit val to_string : t -> string val id : t -> int val hash : t -> Hash.t module Set : Set.S with type elt = t module Map : Map.S with type key = t end module type Style = sig val style : Ocolor_types.style end module Make (X : Info) (S : Style) () : Id with type info = X.info = struct module Ordering = struct type t = { id : int; info : X.info } let compare (x : t) (y : t) : int = Int.compare x.id y.id let equal x y = Int.equal x.id y.id let format ppf t = Format.pp_open_stag ppf (Ocolor_format.Ocolor_style_tag S.style); X.format ppf t.info; (* Format.pp_print_int ppf t.id; (* uncomment for precise uid debug *) *) Format.pp_close_stag ppf () end include Ordering type info = X.info let counter = ref 0 let fresh (info : X.info) : t = incr counter; { id = !counter; info } let get_info (uid : t) : X.info = uid.info let map_info f { id; info } = { id; info = f info } let id (x : t) : int = x.id let to_string t = X.to_string t.info let hash t = X.hash t.info module Set = Set.Make (Ordering) module Map = Map.Make (Ordering) end (* - Raw idents - *) module MarkedString = struct type info = string Mark.pos let to_string (s, _) = s let format fmt i = String.format fmt (to_string i) let equal = Mark.equal String.equal let compare = Mark.compare String.compare let hash = Mark.hash String.hash end module Gen (S : Style) () = Make (MarkedString) (S) () (* - Modules, paths and qualified idents - *) module Module = Gen (struct let style = Ocolor_types.(Fg (C4 blue)) end) () module Path = struct type t = Module.t list let format ppf p = Format.pp_print_list ~pp_sep:(fun _ () -> ()) (fun ppf m -> Format.fprintf ppf "%a@{<cyan>.@}" Module.format m) ppf p let to_string p = String.concat "." (List.map Module.to_string p) let equal = List.equal Module.equal let compare = List.compare Module.compare let strip prefix p0 = let rec aux prefix p = match prefix, p with | pfx1 :: pfx, p1 :: p -> if Module.equal pfx1 p1 then aux pfx p else p0 | [], p -> p | _ -> p0 in aux prefix p0 let strip_up_to modname p0 = let rec aux p = match p with | p1 :: p -> if Module.equal modname p1 then p else aux p | [] -> p0 in aux p0 let rec last_member = function | [m] -> Some m | _ :: p -> last_member p | [] -> None end module QualifiedMarkedString = struct type info = Path.t * MarkedString.info let to_string (p, i) = Format.asprintf "%a%a" Path.format p MarkedString.format i let format fmt (p, i) = Path.format fmt p; MarkedString.format fmt i let equal (p1, i1) (p2, i2) = Path.equal p1 p2 && MarkedString.equal i1 i2 let compare (p1, i1) (p2, i2) = match Path.compare p1 p2 with 0 -> MarkedString.compare i1 i2 | n -> n let hash (p, i) = let open Hash.Op in Hash.list Module.hash p % MarkedString.hash i let format_shortpath ppf (p, i) = Path.format ppf (Option.to_list (Path.last_member p)); MarkedString.format ppf i end module type Qualified = sig include Id with type info = Path.t * MarkedString.info val fresh : Path.t -> MarkedString.info -> t val path : t -> Path.t val get_info : t -> MarkedString.info val base : t -> string val hash : strip:Module.t option -> t -> Hash.t val format_shortpath : Format.formatter -> t -> unit end module Gen_qualified (S : Style) () : Qualified = struct include Make (QualifiedMarkedString) (S) () let fresh path t = fresh (path, t) let hash ~strip t = let p, i = get_info t in let p = match strip with Some m -> Path.strip_up_to m p | None -> p in QualifiedMarkedString.hash (p, i) let format_shortpath ppf t = Format.pp_open_stag ppf (Ocolor_format.Ocolor_style_tag S.style); QualifiedMarkedString.format_shortpath ppf (get_info t); Format.pp_close_stag ppf () let path t = fst (get_info t) let get_info t = snd (get_info t) let base t = Mark.remove (get_info t) end
sectionYPositions = computeSectionYPositions($el), 10)"
x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)"
>