[{"data":1,"prerenderedAt":1372},["ShallowReactive",2],{"navigation_docs":3,"-api-zocam-span":101,"-api-zocam-span-surround":1367},[4,23,66],{"title":5,"icon":6,"path":7,"stem":8,"children":9,"page":22},"Guide","i-lucide-book-open","\u002Fguide","1.guide",[10,14,18],{"title":11,"path":12,"stem":13},"Introduction","\u002Fguide\u002Fintroduction","1.guide\u002F1.introduction",{"title":15,"path":16,"stem":17},"Getting started","\u002Fguide\u002Fgetting-started","1.guide\u002F2.getting-started",{"title":19,"path":20,"stem":21},"Pieces and sets","\u002Fguide\u002Fpieces-and-sets","1.guide\u002F3.pieces-and-sets",false,{"title":24,"icon":25,"path":26,"stem":27,"children":28},"Design (ADRs)","i-lucide-drafting-compass","\u002Fdesign","2.design",[29,32],{"title":30,"path":26,"stem":31},"Design decisions (ADRs)","2.design\u002Findex",{"title":33,"icon":34,"path":35,"stem":36,"children":37,"page":22},"Decision records","i-lucide-scroll-text","\u002Fdesign\u002Fadrs","2.design\u002Fadrs",[38,42,46,50,54,58,62],{"title":39,"path":40,"stem":41},"ADR-001: The refinement-chain model for calendar points","\u002Fdesign\u002Fadrs\u002F001-refinement-chain","2.design\u002Fadrs\u002F001-refinement-chain",{"title":43,"path":44,"stem":45},"ADR-002: Sets first — the Span algebra","\u002Fdesign\u002Fadrs\u002F002-set-primary-spans","2.design\u002Fadrs\u002F002-set-primary-spans",{"title":47,"path":48,"stem":49},"ADR-003: Overflow policy — clamp by default, skip on request","\u002Fdesign\u002Fadrs\u002F003-overflow-policy","2.design\u002Fadrs\u002F003-overflow-policy",{"title":51,"path":52,"stem":53},"ADR-004: Fortnights as every-k scopes","\u002Fdesign\u002Fadrs\u002F004-fortnight-scopes","2.design\u002Fadrs\u002F004-fortnight-scopes",{"title":55,"path":56,"stem":57},"ADR-005: One denotation function, and what DST does to it","\u002Fdesign\u002Fadrs\u002F005-shared-denotation","2.design\u002Fadrs\u002F005-shared-denotation",{"title":59,"path":60,"stem":61},"ADR-006: Zocam is a standalone, released library","\u002Fdesign\u002Fadrs\u002F006-standalone-library","2.design\u002Fadrs\u002F006-standalone-library",{"title":63,"path":64,"stem":65},"ADR-007: A set is one value — struct answers, enumerable shapes","\u002Fdesign\u002Fadrs\u002F007-one-value-sets","2.design\u002Fadrs\u002F007-one-value-sets",{"title":67,"path":68,"stem":69,"children":70,"icon":100},"API Reference","\u002Fapi","3.api\u002Findex",[71,72,76,80,84,88,92,96],{"title":67,"path":68,"stem":69},{"title":73,"path":74,"stem":75},"Zocam","\u002Fapi\u002Fzocam","3.api\u002Fzocam",{"title":77,"path":78,"stem":79},"Zocam.Intervals","\u002Fapi\u002Fzocam-intervals","3.api\u002Fzocam-intervals",{"title":81,"path":82,"stem":83},"Zocam.ISO","\u002Fapi\u002Fzocam-iso","3.api\u002Fzocam-iso",{"title":85,"path":86,"stem":87},"Zocam.Point","\u002Fapi\u002Fzocam-point","3.api\u002Fzocam-point",{"title":89,"path":90,"stem":91},"Zocam.Point.ComposeError","\u002Fapi\u002Fzocam-point-composeerror","3.api\u002Fzocam-point-composeerror",{"title":93,"path":94,"stem":95},"Zocam.Span","\u002Fapi\u002Fzocam-span","3.api\u002Fzocam-span",{"title":97,"path":98,"stem":99},"Zocam.Span.Arc","\u002Fapi\u002Fzocam-span-arc","3.api\u002Fzocam-span-arc","i-lucide-braces",{"id":102,"title":93,"body":103,"description":1360,"extension":1361,"links":1362,"meta":1363,"navigation":1364,"path":94,"seo":1365,"stem":95,"__hash__":1366},"docs\u002F3.api\u002Fzocam-span.md",{"type":104,"value":105,"toc":1329},"minimark",[106,129,138,141,147,157,165,200,205,208,214,225,231,235,278,290,294,301,307,316,320,356,360,382,386,422,426,432,476,492,497,506,511,520,525,572,577,586,590,596,605,617,623,634,640,646,685,688,739,764,769,772,778,781,787,790,796,805,811,817,823,832,838,843,852,855,861,864,870,875,884,893,900,903,909,912,918,923,932,935,941,947,956,959,962,968,973,982,985,991,994,997,1003,1009,1015,1018,1024,1029,1038,1048,1051,1057,1063,1072,1077,1083,1094,1100,1105,1114,1130,1136,1149,1152,1155,1161,1164,1170,1176,1182,1187,1196,1199,1204,1210,1215,1224,1227,1230,1236,1241,1250,1258,1264,1274,1280,1285,1294,1297,1303,1306,1312,1315,1325],[107,108,109,115,116,120,121,128],"p",{},[110,111,114],"span",{"className":112},[113],"ai-slop","AI SLOP"," An AI agent wrote the docstrings; ",[117,118,119],"code",{},"mix docs"," generated this page. ",[122,123,127],"a",{"href":124,"rel":125},"https:\u002F\u002Fgithub.com\u002Fyuri4n",[126],"nofollow","yuri4n",", a senior engineer, gave the direction and did the review. The review is human, thus errors can stay.",[107,130,131],{},[122,132,137],{"href":133,"rel":134,"className":135},"https:\u002F\u002Fgithub.com\u002Fyuri4n\u002Fzocam\u002Fblob\u002Fmain\u002Flib\u002Fzocam\u002Fspan.ex#L9",[126],[136],"source-link","Source on GitHub ↗",[107,139,140],{},"Sets of instants built from calendar points: arcs, unions,\nintersections, complements, and ordinal selection.",[107,142,143,144,146],{},"This module is the set layer over ",[117,145,85],{},". The layers:",[148,149,154],"pre",{"className":150,"code":152,"language":153},[151],"language-text","Point ──▶ Arc ──▶ Span ──▶ ground\u002F3 ──▶ Zocam.Intervals\n(thing)   (from..until    (recursive     (linear kernel,\n           + closings      set: the       already tested)\n           + step)         algebra)\n","text",[117,155,152],{"__ignoreMap":156},"",[107,158,159,160,164],{},"A span is one recursive type. The ",[161,162,163],"em",{},"set"," is primary and a single\ninterval is only a one-arc set. The reason is closure: the\ncomplement of one arc is already two pieces, and a diff can cut one\ninterval into two. A standalone interval type cannot be closed\nunder its own operators.",[107,166,167,168,170,171,174,175,178,179,182,183,170,186,189,190,178,193,196,197,199],{},"Keep the names apart: ",[117,169,97],{}," is ",[161,172,173],{},"one symbolic piece","\nand ",[117,176,177],{},"t:t\u002F0"," is the ",[161,180,181],{},"symbolic set"," built over such pieces, while\n",[117,184,185],{},"t:Zocam.Intervals.interval\u002F0",[161,187,188],{},"one concrete piece"," and\n",[117,191,192],{},"t:Zocam.Intervals.t\u002F0",[161,194,195],{},"concrete set",". \"The four names\" in\nthe ",[117,198,73],{}," moduledoc shows the full two-by-two map.",[201,202,204],"h2",{"id":203},"recipes","Recipes",[107,206,207],{},"You want every second Friday, 09:00–12:00, as concrete UTC\nintervals. Do these steps: name the day, set the rhythm, cut the\nhours, intersect, and ground. (January 2026 has Fridays on the\n2nd, 9th, 16th, 23rd, and 30th; the anchor Jan 2 keeps the 2nd,\nthe 16th, and the 30th.)",[148,209,212],{"className":210,"code":211,"language":153},[151],"iex> fridays =\n...>   Zocam.Point.weekday(:friday)\n...>   |> Zocam.Point.every(2, ~D[2026-01-02])\n...>   |> Zocam.Span.of()\niex> morning =\n...>   Zocam.Span.arc!(\n...>     from: Zocam.Point.time(~T[09:00:00]),\n...>     until: Zocam.Point.time(~T[12:00:00])\n...>   )\niex> span = Zocam.Span.intersection([fridays, morning])\niex> horizon = %{\n...>   from: ~U[2026-01-01 00:00:00Z],\n...>   until: ~U[2026-02-01 00:00:00Z],\n...>   left: :closed,\n...>   right: :open\n...> }\niex> Zocam.Span.ground(span, horizon, \"Etc\u002FUTC\").intervals\n[\n  %{from: ~U[2026-01-02 09:00:00Z], until: ~U[2026-01-02 12:00:00Z], left: :closed, right: :open},\n  %{from: ~U[2026-01-16 09:00:00Z], until: ~U[2026-01-16 12:00:00Z], left: :closed, right: :open},\n  %{from: ~U[2026-01-30 09:00:00Z], until: ~U[2026-01-30 12:00:00Z], left: :closed, right: :open}\n]\n",[117,213,211],{"__ignoreMap":156},[107,215,216,217,220,221,224],{},"You want the last working day of each month. Select it with\n",[117,218,219],{},"nth\u002F3",", then ask with ",[117,222,223],{},"member?\u002F2"," — no horizon needed. April 2026\nends on Thursday the 30th; May 2026 ends on Sunday the 31st, so\nits last working day is Friday the 29th:",[148,226,229],{"className":227,"code":228,"language":153},[151],"iex> weekdays =\n...>   Zocam.Span.arc!(\n...>     from: Zocam.Point.weekday(:monday),\n...>     until: Zocam.Point.weekday(:friday)\n...>   )\niex> last_working_day = Zocam.Span.nth(-1, weekdays, per: :month)\niex> Zocam.Span.member?(last_working_day, ~U[2026-04-30 12:00:00Z])\ntrue\niex> Zocam.Span.member?(last_working_day, ~U[2026-05-29 12:00:00Z])\ntrue\niex> Zocam.Span.member?(last_working_day, ~U[2026-05-31 12:00:00Z])\nfalse\n",[117,230,228],{"__ignoreMap":156},[201,232,234],{"id":233},"two-evaluation-regimes","Two evaluation regimes",[236,237,238,266],"ul",{},[239,240,241,245,246,249,250,253,254,257,258,261,262,265],"li",{},[242,243,244],"strong",{},"Within one cycle"," the algebra is eager where it can be: when\nsame-scope arc nodes merge in a union, the plain arcs (one\nsegment, both sides closed, no step, no wrap) compact to sorted,\ndisjoint integer cell ranges (january=1..december=12,\nmonday=1..sunday=7), so ",[117,247,248],{},"Jan..Jan"," plus ",[117,251,252],{},"Feb..Feb"," IS ",[117,255,256],{},"Jan..Feb",".\nAll other arcs (wraps, steps, ordinals, open sides) ride along\nunchanged: the form is quasi-canonical, not minimal. A step\nsamples cells forward from the ",[117,259,260],{},"from"," bound after the ",[117,263,264],{},"until","\nbound has been resolved across the wrap seam, so the sampling\nphase runs through the seam.",[239,267,268,271,272,189,274,277],{},[242,269,270],{},"Across cycles"," the tree stays symbolic and lazy: \"Wednesdays\nin May\" has no finite normal form before grounding, so the\nintersection node holds it as data. This is the interpreter\npattern: constructors build a free algebra, and ",[117,273,223],{},[117,275,276],{},"ground\u002F3"," are its two interpreters.",[107,279,280,281,189,283,285,286,289],{},"Both interpreters share ONE denotation function: clamping, ordinal\nskipping, and closings behave identically in ",[117,282,223],{},[117,284,276],{},". Keeping them equal is the keystone property test:\n",[117,287,288],{},"member?(span, t) == member of t in ground(span, horizon, tz)",".",[201,291,293],{"id":292},"how-an-arc-becomes-kernel-intervals","How an arc becomes kernel intervals",[107,295,296,297,300],{},"The shared denotation core works in ",[161,298,299],{},"wall time"," and meets the real\ntimeline only at the very end:",[148,302,305],{"className":303,"code":304,"language":153},[151],"arc                     one per scope instance\n │ chain_window\u002F3        (year 2026, week of Jan 5, ...)\n ▼\nwall windows            [~N[2026-11-01 00:00:00],\n │ preimage\u002F3            ~N[2027-02-01 00:00:00])\n ▼\nUTC intervals           the tzdata period table maps each wall\n │ clip + compress       window to 0, 1, or 2 UTC pieces\n ▼\nZocam.Intervals\n",[117,306,304],{"__ignoreMap":156},[107,308,309,311,312,315],{},[117,310,223],{}," stops at the second stage: it reads the wall clock of\nthe given ",[117,313,314],{},"DateTime"," and checks the wall windows directly. That is\nwhy the two interpreters cannot disagree: they run the same code up\nto the point where a timezone exists.",[201,317,319],{"id":318},"wrap-around","Wrap-around",[107,321,322,325,326,329,330,333,334,337,338,341,342,344,345,348,349,351,352,355],{},[117,323,324],{},"Fri..Mon",", ",[117,327,328],{},"Nov..Feb",", and ",[117,331,332],{},"22:00..06:00"," are legal arcs. A wrap\nis decided at the chain level, before closings expand: ",[117,335,336],{},"May..May","\nis the single-unit case, never a wrap. A wrapping arc materializes\n",[161,339,340],{},"forward",": the until bound resolves in the next cycle instance, so\n",[117,343,328],{}," becomes one continuous block ",[117,346,347],{},"[Nov 1, Feb 1)"," of the\nfollowing year and nothing needs to re-fuse at the seam.\n",[117,350,223],{}," therefore checks the instance of the probed instant\n",[161,353,354],{},"and its predecessor",": a block that started last instance can\nstill cover the probe.",[201,357,359],{"id":358},"timezone","Timezone",[107,361,362,363,365,366,368,369,371,372,374,375,377,378,381],{},"Only ",[117,364,276],{}," and ",[117,367,223],{}," on real ",[117,370,314],{},"s meet the\ntimeline. ",[117,373,223],{}," reads the wall clock of the given DateTime.\n",[117,376,276],{}," resolves wall times in the given timezone: an instance\ncan ground to ",[161,379,380],{},"two"," kernel intervals on a fall-back day (the wall\nwindow exists twice), and a wall time inside a spring-forward gap\ngrounds to nothing.",[201,383,385],{"id":384},"one-calendar","One calendar",[107,387,388,389,391,392,395,396,399,400,402,403,329,405,408,409,412,413,365,416,419,420,289],{},"Every ",[117,390,314],{}," this module takes must be on ",[117,393,394],{},"Calendar.ISO",":\n",[117,397,398],{},"absolute!\u002F1",", the ",[117,401,276],{}," horizon, ",[117,404,223],{},[117,406,407],{},"stream\u002F3","\nall check it and refuse anything else. The wall dates that come out\nof those instants are read as ISO dates — ",[117,410,411],{},"instance_index\u002F2"," reads\n",[117,414,415],{},"date.year",[117,417,418],{},"date.month"," as Gregorian numbers — so the check is\nwhat makes the reading true. See ",[117,421,81],{},[201,423,425],{"id":424},"types","Types",[427,428,430],"h3",{"id":429},"horizon",[117,431,429],{},[148,433,437],{"className":434,"code":435,"language":436,"meta":156,"style":156},"language-elixir shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","@type horizon() :: %{\n  from: DateTime.t(),\n  until: DateTime.t(),\n  left: Zocam.Intervals.closing(),\n  right: Zocam.Intervals.closing()\n}\n","elixir",[117,438,439,446,452,458,464,470],{"__ignoreMap":156},[110,440,443],{"class":441,"line":442},"line",1,[110,444,445],{},"@type horizon() :: %{\n",[110,447,449],{"class":441,"line":448},2,[110,450,451],{},"  from: DateTime.t(),\n",[110,453,455],{"class":441,"line":454},3,[110,456,457],{},"  until: DateTime.t(),\n",[110,459,461],{"class":441,"line":460},4,[110,462,463],{},"  left: Zocam.Intervals.closing(),\n",[110,465,467],{"class":441,"line":466},5,[110,468,469],{},"  right: Zocam.Intervals.closing()\n",[110,471,473],{"class":441,"line":472},6,[110,474,475],{},"}\n",[107,477,478,479,481,482,484,485,488,489,491],{},"A bounded evaluation window for ",[117,480,276],{},": a kernel-shaped map\nwhose two endpoints are both present and both ",[117,483,314],{},". Many\nspans are infinite, so an unbounded ground cannot terminate — the\ntype has no ",[117,486,487],{},"nil"," sides. When there is no right bound, use\n",[117,490,407],{}," instead.",[427,493,495],{"id":494},"n",[117,496,494],{},[148,498,500],{"className":434,"code":499,"language":436,"meta":156,"style":156},"@type n() :: pos_integer() | neg_integer()\n",[117,501,502],{"__ignoreMap":156},[110,503,504],{"class":441,"line":442},[110,505,499],{},[427,507,509],{"id":508},"step",[117,510,508],{},[148,512,514],{"className":434,"code":513,"language":436,"meta":156,"style":156},"@type step() :: {pos_integer(), Zocam.Point.unit() | time_unit()}\n",[117,515,516],{"__ignoreMap":156},[110,517,518],{"class":441,"line":442},[110,519,513],{},[427,521,523],{"id":522},"t",[117,524,522],{},[148,526,528],{"className":434,"code":527,"language":436,"meta":156,"style":156},"@type t() ::\n  {:arcs, Zocam.Point.scope(), Zocam.Point.grain_class(),\n   [Zocam.Span.Arc.t(), ...]}\n  | {:absolute, Zocam.Intervals.interval()}\n  | {:union, [t()]}\n  | {:intersection, [t()]}\n  | {:complement, t()}\n  | {:nth, n(), t(), Zocam.Point.cycle()}\n",[117,529,530,535,540,545,550,555,560,566],{"__ignoreMap":156},[110,531,532],{"class":441,"line":442},[110,533,534],{},"@type t() ::\n",[110,536,537],{"class":441,"line":448},[110,538,539],{},"  {:arcs, Zocam.Point.scope(), Zocam.Point.grain_class(),\n",[110,541,542],{"class":441,"line":454},[110,543,544],{},"   [Zocam.Span.Arc.t(), ...]}\n",[110,546,547],{"class":441,"line":460},[110,548,549],{},"  | {:absolute, Zocam.Intervals.interval()}\n",[110,551,552],{"class":441,"line":466},[110,553,554],{},"  | {:union, [t()]}\n",[110,556,557],{"class":441,"line":472},[110,558,559],{},"  | {:intersection, [t()]}\n",[110,561,563],{"class":441,"line":562},7,[110,564,565],{},"  | {:complement, t()}\n",[110,567,569],{"class":441,"line":568},8,[110,570,571],{},"  | {:nth, n(), t(), Zocam.Point.cycle()}\n",[427,573,575],{"id":574},"time_unit",[117,576,574],{},[148,578,580],{"className":434,"code":579,"language":436,"meta":156,"style":156},"@type time_unit() :: :hour | :minute | :second\n",[117,581,582],{"__ignoreMap":156},[110,583,584],{"class":441,"line":442},[110,585,579],{},[201,587,589],{"id":588},"functions","Functions",[427,591,593],{"id":592},"absolute",[117,594,595],{},"absolute!",[148,597,599],{"className":434,"code":598,"language":436,"meta":156,"style":156},"@spec absolute!(Zocam.Intervals.valid_interval()) :: t()\n",[117,600,601],{"__ignoreMap":156},[110,602,603],{"class":441,"line":442},[110,604,598],{},[107,606,607,608,610,611,613,614,616],{},"Wrap an already-linear interval (",[117,609,77],{}," spec) as a\nspan, e.g. \"from 2026-05-23 onward\". This is where unbounded sides\nlive: cyclic arcs always have both bounds, absolute ones may not.\nBounds must be ",[117,612,314],{}," (or ",[117,615,487],{}," for a ray): a span meets the\ntimeline as instants, never as bare wall values.",[148,618,621],{"className":619,"code":620,"language":153},[151],"iex> onward = Zocam.Span.absolute!(from: ~U[2026-05-23 00:00:00Z])\niex> Zocam.Span.member?(onward, ~U[2026-08-01 12:00:00Z])\ntrue\niex> Zocam.Span.member?(onward, ~U[2026-05-22 12:00:00Z])\nfalse\n",[117,622,620],{"__ignoreMap":156},[107,624,625,626,629,630,633],{},"The pitfall: a wall value is not an instant, so a ",[117,627,628],{},"Time"," bound is\nrefused here — build a daily window with ",[117,631,632],{},"arc!\u002F1"," instead:",[148,635,638],{"className":636,"code":637,"language":153},[151],"iex> Zocam.Span.absolute!(from: ~T[09:00:00])\n** (ArgumentError) absolute!\u002F1 from: must be a DateTime or nil, got ~T[09:00:00]. Wall values (Time, month atoms) belong to Point and arc!\u002F1.\n",[117,639,637],{"__ignoreMap":156},[427,641,643],{"id":642},"arc",[117,644,645],{},"arc!",[148,647,649],{"className":434,"code":648,"language":436,"meta":156,"style":156},"@spec arc!(\n  from: Zocam.Point.t(),\n  until: Zocam.Point.t(),\n  left: Zocam.Intervals.closing(),\n  right: Zocam.Intervals.closing(),\n  step: pos_integer() | step()\n) :: t()\n",[117,650,651,656,661,666,670,675,680],{"__ignoreMap":156},[110,652,653],{"class":441,"line":442},[110,654,655],{},"@spec arc!(\n",[110,657,658],{"class":441,"line":448},[110,659,660],{},"  from: Zocam.Point.t(),\n",[110,662,663],{"class":441,"line":454},[110,664,665],{},"  until: Zocam.Point.t(),\n",[110,667,668],{"class":441,"line":460},[110,669,463],{},[110,671,672],{"class":441,"line":466},[110,673,674],{},"  right: Zocam.Intervals.closing(),\n",[110,676,677],{"class":441,"line":472},[110,678,679],{},"  step: pos_integer() | step()\n",[110,681,682],{"class":441,"line":562},[110,683,684],{},") :: t()\n",[107,686,687],{},"Build a one-arc span between two points of the same form.",[107,689,690,691,325,694,697,698,701,702,325,705,708,709,712,713,715,716,719,720,723,724,727,728,731,732,734,735,738],{},"Options: ",[117,692,693],{},"from:",[117,695,696],{},"until:"," (both ",[117,699,700],{},"Point.t()",", required, same scope\nand grain class), ",[117,703,704],{},"left:",[117,706,707],{},"right:"," (closings; defaults: ",[117,710,711],{},":closed","\non both sides for bare-unit grains, ",[117,714,711],{},"\u002F",[117,717,718],{},":open"," when the\ngrain is ",[117,721,722],{},":time","), ",[117,725,726],{},"step:"," (default: no sampling). A bare integer\nstep means ",[117,729,730],{},"{n, grain}"," and is legal only at discrete grains; at\n",[117,733,722],{}," grain the unit is mandatory (",[117,736,737],{},"{15, :minute}",").",[107,740,741,744,745,747,748,751,752,755,756,759,760,763],{},[117,742,743],{},"from == until"," names the single unit (",[117,746,718],{}," on any side excludes\nit entirely, so the result is ",[117,749,750],{},"empty\u002F0","). A bound order that runs\nbackward in cycle order wraps: ",[117,753,754],{},"november..february",",\n",[117,757,758],{},"friday..monday",". On the ",[117,761,762],{},":absolute"," scope there is no cycle to\nwrap in, so backward bounds raise.",[765,766,768],"h4",{"id":767},"examples","Examples",[107,770,771],{},"The common arc: a block of weekdays, \"Friday through Monday\".\nJan 10 2026 is a Saturday; Jan 7 is a Wednesday:",[148,773,776],{"className":774,"code":775,"language":153},[151],"iex> weekend = Zocam.Span.arc!(\n...>   from: Zocam.Point.weekday(:friday),\n...>   until: Zocam.Point.weekday(:monday)\n...> )\niex> Zocam.Span.member?(weekend, ~U[2026-01-10 12:00:00Z])\ntrue\niex> Zocam.Span.member?(weekend, ~U[2026-01-07 12:00:00Z])\nfalse\n",[117,777,775],{"__ignoreMap":156},[107,779,780],{},"A time window with a step: \"every 15 minutes from 09:00 to 17:00\":",[148,782,785],{"className":783,"code":784,"language":153},[151],"iex> every_15 = Zocam.Span.arc!(\n...>   from: Zocam.Point.time(~T[09:00:00]),\n...>   until: Zocam.Point.time(~T[17:00:00]),\n...>   step: {15, :minute}\n...> )\niex> Zocam.Span.member?(every_15, ~U[2026-05-15 09:15:00Z])\ntrue\niex> Zocam.Span.member?(every_15, ~U[2026-05-15 09:07:00Z])\nfalse\n",[117,786,784],{"__ignoreMap":156},[107,788,789],{},"The edge: backward bounds wrap. \"November through February\" is one\ncontinuous block across the year seam, so December is inside:",[148,791,794],{"className":792,"code":793,"language":153},[151],"iex> winter = Zocam.Span.arc!(\n...>   from: Zocam.Point.month(:november),\n...>   until: Zocam.Point.month(:february)\n...> )\niex> Zocam.Span.member?(winter, ~U[2026-12-15 12:00:00Z])\ntrue\niex> Zocam.Span.member?(winter, ~U[2027-02-15 12:00:00Z])\ntrue\niex> Zocam.Span.member?(winter, ~U[2026-06-15 12:00:00Z])\nfalse\n",[117,795,793],{"__ignoreMap":156},[107,797,798,799,801,802,804],{},"The pitfall: ",[117,800,336],{}," with an open side is the empty set, never\n\"everything except May\". Wrap is decided at the chain level, before\nclosings expand, and a whole-unit ",[117,803,718],{}," excludes the whole unit:",[148,806,809],{"className":807,"code":808,"language":153},[151],"iex> Zocam.Span.arc!(\n...>   from: Zocam.Point.month(:may),\n...>   until: Zocam.Point.month(:may),\n...>   left: :open,\n...>   right: :open\n...> )\n{:union, []}\n",[117,810,808],{"__ignoreMap":156},[107,812,813,814,816],{},"On the ",[117,815,762],{}," scope there is no cycle to wrap in, so backward\nbounds raise instead:",[148,818,821],{"className":819,"code":820,"language":153},[151],"iex> Zocam.Span.arc!(from: Zocam.Point.year(2027), until: Zocam.Point.year(2026))\n** (ArgumentError) absolute bounds run backward: [year: 2027] is after [year: 2026]. The timeline has no cycle to wrap in; swap the bounds.\n",[117,822,820],{"__ignoreMap":156},[107,824,825,826,828,829,831],{},"A bare integer step at ",[117,827,722],{}," grain is rejected — ",[117,830,628],{}," has no\nunit cell, so the unit must be explicit:",[148,833,836],{"className":834,"code":835,"language":153},[151],"iex> Zocam.Span.arc!(\n...>   from: Zocam.Point.time(~T[09:00:00]),\n...>   until: Zocam.Point.time(~T[17:00:00]),\n...>   step: 2\n...> )\n** (ArgumentError) a bare integer step counts grain units, and :time has no unit cell. Give the unit explicitly: {2, :minute}, {2, :hour}, ...\n",[117,837,835],{"__ignoreMap":156},[427,839,841],{"id":840},"complement",[117,842,840],{},[148,844,846],{"className":434,"code":845,"language":436,"meta":156,"style":156},"@spec complement(t()) :: t()\n",[117,847,848],{"__ignoreMap":156},[110,849,850],{"class":441,"line":442},[110,851,845],{},[107,853,854],{},"Everything outside the given span.",[148,856,859],{"className":857,"code":858,"language":153},[151],"iex> not_may = Zocam.Span.complement(Zocam.Span.of(Zocam.Point.month(:may)))\niex> Zocam.Span.member?(not_may, ~U[2026-05-15 12:00:00Z])\nfalse\niex> Zocam.Span.member?(not_may, ~U[2026-06-15 12:00:00Z])\ntrue\n",[117,860,858],{"__ignoreMap":156},[107,862,863],{},"A double complement collapses back to the original span:",[148,865,868],{"className":866,"code":867,"language":153},[151],"iex> may = Zocam.Span.of(Zocam.Point.month(:may))\niex> Zocam.Span.complement(Zocam.Span.complement(may)) == may\ntrue\n",[117,869,867],{"__ignoreMap":156},[427,871,873],{"id":872},"diff",[117,874,872],{},[148,876,878],{"className":434,"code":877,"language":436,"meta":156,"style":156},"@spec diff(t(), t()) :: t()\n",[117,879,880],{"__ignoreMap":156},[110,881,882],{"class":441,"line":442},[110,883,877],{},[107,885,886,887,889,890,289],{},"Set difference: ",[117,888,122],{}," without ",[117,891,892],{},"b",[107,894,895,896,899],{},"Defined as ",[117,897,898],{},"intersection([a, complement(b)])",". One-versus-many and\nmany-versus-one are not special cases: \"many\" is already a union\nvalue on either side. The linear kernel computes its own diff the\nsame way, so the two layers agree by construction.",[107,901,902],{},"Weekdays without Wednesdays — Jan 6 2026 is a Tuesday, Jan 7 a\nWednesday:",[148,904,907],{"className":905,"code":906,"language":153},[151],"iex> weekdays = Zocam.Span.arc!(\n...>   from: Zocam.Point.weekday(:monday),\n...>   until: Zocam.Point.weekday(:friday)\n...> )\niex> no_wednesdays = Zocam.Span.diff(weekdays, Zocam.Span.of(Zocam.Point.weekday(:wednesday)))\niex> Zocam.Span.member?(no_wednesdays, ~U[2026-01-06 12:00:00Z])\ntrue\niex> Zocam.Span.member?(no_wednesdays, ~U[2026-01-07 12:00:00Z])\nfalse\n",[117,908,906],{"__ignoreMap":156},[107,910,911],{},"Subtracting nothing changes nothing — the empty span absorbs\ninstead of erasing:",[148,913,916],{"className":914,"code":915,"language":153},[151],"iex> may = Zocam.Span.of(Zocam.Point.month(:may))\niex> Zocam.Span.diff(may, Zocam.Span.empty()) == may\ntrue\n",[117,917,915],{"__ignoreMap":156},[427,919,921],{"id":920},"empty",[117,922,920],{},[148,924,926],{"className":434,"code":925,"language":436,"meta":156,"style":156},"@spec empty() :: t()\n",[117,927,928],{"__ignoreMap":156},[110,929,930],{"class":441,"line":442},[110,931,925],{},[107,933,934],{},"The empty set: a union of nothing.",[148,936,939],{"className":937,"code":938,"language":153},[151],"iex> Zocam.Span.empty()\n{:union, []}\n",[117,940,938],{"__ignoreMap":156},[427,942,944],{"id":943},"empty-1",[117,945,946],{},"empty?",[148,948,950],{"className":434,"code":949,"language":436,"meta":156,"style":156},"@spec empty?(t(), horizon(), String.t()) :: boolean()\n",[117,951,952],{"__ignoreMap":156},[110,953,954],{"class":441,"line":442},[110,955,949],{},[107,957,958],{},"Does the span contain no instant inside the horizon?",[107,960,961],{},"February 2026 has four Wednesdays, so its \"5th Wednesday\" is empty\nthere — and not empty in April, which has five:",[148,963,966],{"className":964,"code":965,"language":153},[151],"iex> fifth_wed = Zocam.Span.of(Zocam.Point.day({:nth, 5, :wednesday}))\niex> feb = %{from: ~U[2026-02-01 00:00:00Z], until: ~U[2026-03-01 00:00:00Z], left: :closed, right: :open}\niex> Zocam.Span.empty?(fifth_wed, feb, \"Etc\u002FUTC\")\ntrue\niex> apr = %{from: ~U[2026-04-01 00:00:00Z], until: ~U[2026-05-01 00:00:00Z], left: :closed, right: :open}\niex> Zocam.Span.empty?(fifth_wed, apr, \"Etc\u002FUTC\")\nfalse\n",[117,967,965],{"__ignoreMap":156},[427,969,971],{"id":970},"ground",[117,972,970],{},[148,974,976],{"className":434,"code":975,"language":436,"meta":156,"style":156},"@spec ground(t(), horizon(), String.t()) :: Zocam.Intervals.t()\n",[117,977,978],{"__ignoreMap":156},[110,979,980],{"class":441,"line":442},[110,981,975],{},[107,983,984],{},"Evaluate the span over a bounded horizon into the linear kernel.",[107,986,987,988,990],{},"Enumerates every scope instance that intersects the horizon,\ngrounds each fully (an instance may yield more than one kernel\ninterval on DST fall-back days), then clips to the horizon and\ncompresses. The horizon must be bounded on both sides: many spans\nare infinite, so an unbounded ground cannot terminate — use\n",[117,989,407],{}," when there is no right bound.",[765,992,768],{"id":993},"examples-1",[107,995,996],{},"The common call: one cyclic point, one bounded horizon, UTC.",[148,998,1001],{"className":999,"code":1000,"language":153},[151],"iex> may = Zocam.Span.of(Zocam.Point.month(:may))\niex> horizon = %{\n...>   from: ~U[2026-01-01 00:00:00Z],\n...>   until: ~U[2027-01-01 00:00:00Z],\n...>   left: :closed,\n...>   right: :open\n...> }\niex> Zocam.Span.ground(may, horizon, \"Etc\u002FUTC\").intervals\n[%{from: ~U[2026-05-01 00:00:00Z], until: ~U[2026-06-01 00:00:00Z], left: :closed, right: :open}]\n",[117,1002,1000],{"__ignoreMap":156},[107,1004,1005,1006,1008],{},"The DST fold: on 2026-11-01, America\u002FNew_York sets its clocks\nback, so the wall window 00:30..01:30 exists twice — once in EDT,\nand partly again in EST. One instance grounds to ",[161,1007,380],{}," intervals:",[148,1010,1013],{"className":1011,"code":1012,"language":153},[151],"iex> night = Zocam.Span.arc!(\n...>   from: Zocam.Point.time(~T[00:30:00]),\n...>   until: Zocam.Point.time(~T[01:30:00])\n...> )\niex> fall_back = %{\n...>   from: ~U[2026-11-01 00:00:00Z],\n...>   until: ~U[2026-11-02 00:00:00Z],\n...>   left: :closed,\n...>   right: :open\n...> }\niex> Zocam.Span.ground(night, fall_back, \"America\u002FNew_York\").intervals\n[\n  %{from: ~U[2026-11-01 04:30:00Z], until: ~U[2026-11-01 05:30:00Z], left: :closed, right: :open},\n  %{from: ~U[2026-11-01 06:00:00Z], until: ~U[2026-11-01 06:30:00Z], left: :closed, right: :open}\n]\n",[117,1014,1012],{"__ignoreMap":156},[107,1016,1017],{},"The DST gap: on 2026-03-08 the wall time 02:30 never appears on a\nNew York clock, so that instance grounds to nothing:",[148,1019,1022],{"className":1020,"code":1021,"language":153},[151],"iex> spring = %{\n...>   from: ~U[2026-03-08 00:00:00Z],\n...>   until: ~U[2026-03-09 00:00:00Z],\n...>   left: :closed,\n...>   right: :open\n...> }\niex> Zocam.Span.ground(Zocam.Span.of(Zocam.Point.time(~T[02:30:00])), spring, \"America\u002FNew_York\").intervals\n[]\n",[117,1023,1021],{"__ignoreMap":156},[427,1025,1027],{"id":1026},"intersection",[117,1028,1026],{},[148,1030,1032],{"className":434,"code":1031,"language":436,"meta":156,"style":156},"@spec intersection([t()]) :: t()\n",[117,1033,1034],{"__ignoreMap":156},[110,1035,1036],{"class":441,"line":442},[110,1037,1031],{},[107,1039,1040,1041,1044,1045,289],{},"The intersection of the given spans. ",[117,1042,1043],{},"intersection([])"," is\n",[117,1046,1047],{},"universe\u002F0",[107,1049,1050],{},"A cross-cycle intersection (\"Wednesdays in May\") has no finite\nnormal form before grounding, so the node holds it as data and the\ntwo interpreters answer. May 6 2026 is a Wednesday; Apr 29 is a\nWednesday outside May:",[148,1052,1055],{"className":1053,"code":1054,"language":153},[151],"iex> weds_in_may = Zocam.Span.intersection([\n...>   Zocam.Span.of(Zocam.Point.month(:may)),\n...>   Zocam.Span.of(Zocam.Point.weekday(:wednesday))\n...> ])\niex> Zocam.Span.member?(weds_in_may, ~U[2026-05-06 12:00:00Z])\ntrue\niex> Zocam.Span.member?(weds_in_may, ~U[2026-04-29 12:00:00Z])\nfalse\n",[117,1056,1054],{"__ignoreMap":156},[427,1058,1060],{"id":1059},"member",[117,1061,1062],{},"member?",[148,1064,1066],{"className":434,"code":1065,"language":436,"meta":156,"style":156},"@spec member?(t(), DateTime.t()) :: boolean()\n",[117,1067,1068],{"__ignoreMap":156},[110,1069,1070],{"class":441,"line":442},[110,1071,1065],{},[107,1073,1074,1075,289],{},"Is the instant inside the set? Symbolic: no horizon, no\nenumeration. Reads the wall clock of the given DateTime and applies\nthe same denotation as ",[117,1076,276],{},[148,1078,1081],{"className":1079,"code":1080,"language":153},[151],"iex> may = Zocam.Span.of(Zocam.Point.month(:may))\niex> Zocam.Span.member?(may, ~U[2026-05-15 12:00:00Z])\ntrue\n",[117,1082,1080],{"__ignoreMap":156},[107,1084,1085,1086,1089,1090,1093],{},"Clamping is part of the shared denotation, so the two interpreters\ncannot disagree on it. February 2026 has 28 days; under the\ndefault ",[117,1087,1088],{},":clamp"," the 31st fires on Feb 28, and under ",[117,1091,1092],{},":skip"," it\ndoes not:",[148,1095,1098],{"className":1096,"code":1097,"language":153},[151],"iex> Zocam.Span.member?(Zocam.Span.of(Zocam.Point.day(31)), ~U[2026-02-28 12:00:00Z])\ntrue\niex> literal_31st = Zocam.Point.new!(scope: :month, chain: [day: 31], overflow: :skip)\niex> Zocam.Span.member?(Zocam.Span.of(literal_31st), ~U[2026-02-28 12:00:00Z])\nfalse\n",[117,1099,1097],{"__ignoreMap":156},[427,1101,1103],{"id":1102},"nth",[117,1104,1102],{},[148,1106,1108],{"className":434,"code":1107,"language":436,"meta":156,"style":156},"@spec nth(n(), t(), [{:per, Zocam.Point.cycle()}]) :: t()\n",[117,1109,1110],{"__ignoreMap":156},[110,1111,1112],{"class":441,"line":442},[110,1113,1107],{},[107,1115,1116,1117,1119,1120,1122,1123,1126,1127,1129],{},"Ordinal selection: the ",[117,1118,494],{},"-th grain cell of ",[117,1121,110],{}," inside each\ninstance of the ",[117,1124,1125],{},"per"," cycle. Negative ",[117,1128,494],{}," counts from the end.",[107,1131,1132,1133,1135],{},"A missing ordinal skips the instance (no 5th Wednesday: nothing).\nGrounding widens to whole ",[117,1134,1125],{}," instances before counting, then\nclips to the horizon, so a cut-off January never miscounts its\nlast Friday.",[107,1137,1138,1139,1141,1142,1145,1146,1148],{},"The inner span must be cyclic with day-sized grain cells: ",[117,1140,1102],{},"\ncounts days, and an ",[117,1143,1144],{},"{:absolute, _}"," node or a ",[117,1147,722],{},"-grain leaf\nhas no day cells to count.",[765,1150,768],{"id":1151},"examples-2",[107,1153,1154],{},"The last Friday of each month. January 2026 has Fridays on the\n2nd, 9th, 16th, 23rd, and 30th:",[148,1156,1159],{"className":1157,"code":1158,"language":153},[151],"iex> last_friday = Zocam.Span.nth(-1, Zocam.Span.of(Zocam.Point.weekday(:friday)), per: :month)\niex> Zocam.Span.member?(last_friday, ~U[2026-01-30 12:00:00Z])\ntrue\niex> Zocam.Span.member?(last_friday, ~U[2026-01-23 12:00:00Z])\nfalse\n",[117,1160,1158],{"__ignoreMap":156},[107,1162,1163],{},"The edge: a missing ordinal skips. February 2026 has four\nWednesdays, so its \"5th Wednesday\" names nothing — it does not\nclamp onto the last one. April has five:",[148,1165,1168],{"className":1166,"code":1167,"language":153},[151],"iex> fifth_wed = Zocam.Span.nth(5, Zocam.Span.of(Zocam.Point.weekday(:wednesday)), per: :month)\niex> Zocam.Span.member?(fifth_wed, ~U[2026-04-29 12:00:00Z])\ntrue\niex> Zocam.Span.member?(fifth_wed, ~U[2026-02-25 12:00:00Z])\nfalse\n",[117,1169,1167],{"__ignoreMap":156},[107,1171,1172,1173,1175],{},"The pitfall: \"the first 09:00 of the month\" reads well, but a\n",[117,1174,722],{},"-grain span has no day cells to count. Select the day\nfirst, then intersect with the time window:",[148,1177,1180],{"className":1178,"code":1179,"language":153},[151],"iex> Zocam.Span.nth(1, Zocam.Span.of(Zocam.Point.time(~T[09:00:00])), per: :month)\n** (ArgumentError) nth\u002F3 counts day cells; a :time-grain span has none. Select the day first, then intersect with the time window.\n",[117,1181,1179],{"__ignoreMap":156},[427,1183,1185],{"id":1184},"of",[117,1186,1184],{},[148,1188,1190],{"className":434,"code":1189,"language":436,"meta":156,"style":156},"@spec of(Zocam.Point.t()) :: t()\n",[117,1191,1192],{"__ignoreMap":156},[110,1193,1194],{"class":441,"line":442},[110,1195,1189],{},[107,1197,1198],{},"Lift a point into the set algebra: the set of all instants the\npoint denotes (one grain-sized interval per scope instance).",[107,1200,1201,1202,289],{},"The result is a one-arc node whose bounds are both the point's\nchain, closed on both sides: \"May\" is the arc ",[117,1203,336],{},[148,1205,1208],{"className":1206,"code":1207,"language":153},[151],"iex> may = Zocam.Span.of(Zocam.Point.month(:may))\niex> match?({:arcs, :year, :month, [%Zocam.Span.Arc{}]}, may)\ntrue\niex> Zocam.Span.member?(may, ~U[2026-05-15 12:00:00Z])\ntrue\niex> Zocam.Span.member?(may, ~U[2026-06-01 00:00:00Z])\nfalse\n",[117,1209,1207],{"__ignoreMap":156},[427,1211,1213],{"id":1212},"stream",[117,1214,1212],{},[148,1216,1218],{"className":434,"code":1217,"language":436,"meta":156,"style":156},"@spec stream(t(), DateTime.t(), String.t()) :: Enumerable.t()\n",[117,1219,1220],{"__ignoreMap":156},[110,1221,1222],{"class":441,"line":442},[110,1223,1217],{},[107,1225,1226],{},"Lazily enumerate the span's intervals from an instant forward, in\norder. The stream grounds chunk by chunk (one year at a time, with\na one-year lookahead), so it works without a right bound; take\nfrom it what you need.",[107,1228,1229],{},"The first two Wednesdays of 2026 fall on Jan 7 and Jan 14:",[148,1231,1234],{"className":1232,"code":1233,"language":153},[151],"iex> weds = Zocam.Span.of(Zocam.Point.weekday(:wednesday))\niex> Zocam.Span.stream(weds, ~U[2026-01-01 00:00:00Z], \"Etc\u002FUTC\") |> Enum.take(2)\n[\n  %{from: ~U[2026-01-07 00:00:00Z], until: ~U[2026-01-08 00:00:00Z], left: :closed, right: :open},\n  %{from: ~U[2026-01-14 00:00:00Z], until: ~U[2026-01-15 00:00:00Z], left: :closed, right: :open}\n]\n",[117,1235,1233],{"__ignoreMap":156},[427,1237,1239],{"id":1238},"union",[117,1240,1238],{},[148,1242,1244],{"className":434,"code":1243,"language":436,"meta":156,"style":156},"@spec union([t()]) :: t()\n",[117,1245,1246],{"__ignoreMap":156},[110,1247,1248],{"class":441,"line":442},[110,1249,1243],{},[107,1251,1252,1253,170,1256,289],{},"The union of the given spans. ",[117,1254,1255],{},"union([])",[117,1257,750],{},[148,1259,1262],{"className":1260,"code":1261,"language":153},[151],"iex> weekend = Zocam.Span.union([\n...>   Zocam.Span.of(Zocam.Point.weekday(:saturday)),\n...>   Zocam.Span.of(Zocam.Point.weekday(:sunday))\n...> ])\niex> Zocam.Span.member?(weekend, ~U[2026-01-10 12:00:00Z])\ntrue\n",[117,1263,1261],{"__ignoreMap":156},[107,1265,1266,1267,1270,1271,1273],{},"The edge: same-cycle leaves merge eagerly. January and February\ntile the year cycle side by side, so their union ",[161,1268,1269],{},"is"," the arc\n",[117,1272,256],{}," — one node, not two:",[148,1275,1278],{"className":1276,"code":1277,"language":153},[151],"iex> Zocam.Span.union([\n...>   Zocam.Span.of(Zocam.Point.month(:january)),\n...>   Zocam.Span.of(Zocam.Point.month(:february))\n...> ]) == Zocam.Span.arc!(from: Zocam.Point.month(:january), until: Zocam.Point.month(:february))\ntrue\n",[117,1279,1277],{"__ignoreMap":156},[427,1281,1283],{"id":1282},"universe",[117,1284,1282],{},[148,1286,1288],{"className":434,"code":1287,"language":436,"meta":156,"style":156},"@spec universe() :: t()\n",[117,1289,1290],{"__ignoreMap":156},[110,1291,1292],{"class":441,"line":442},[110,1293,1287],{},[107,1295,1296],{},"The whole timeline: an intersection of no constraints.",[148,1298,1301],{"className":1299,"code":1300,"language":153},[151],"iex> Zocam.Span.universe()\n{:intersection, []}\n",[117,1302,1300],{"__ignoreMap":156},[107,1304,1305],{},"The two constants are dual under complement:",[148,1307,1310],{"className":1308,"code":1309,"language":153},[151],"iex> Zocam.Span.complement(Zocam.Span.empty()) == Zocam.Span.universe()\ntrue\n",[117,1311,1309],{"__ignoreMap":156},[1313,1314],"hr",{},[107,1316,1317],{},[161,1318,1319,1320,1324],{},"Consult ",[122,1321,1323],{"href":1322},"api-reference","api-reference.md"," for complete listing",[1326,1327,1328],"style",{},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":156,"searchDepth":448,"depth":448,"links":1330},[1331,1332,1333,1334,1335,1336,1337,1344],{"id":203,"depth":448,"text":204},{"id":233,"depth":448,"text":234},{"id":292,"depth":448,"text":293},{"id":318,"depth":448,"text":319},{"id":358,"depth":448,"text":359},{"id":384,"depth":448,"text":385},{"id":424,"depth":448,"text":425,"children":1338},[1339,1340,1341,1342,1343],{"id":429,"depth":454,"text":429},{"id":494,"depth":454,"text":494},{"id":508,"depth":454,"text":508},{"id":522,"depth":454,"text":522},{"id":574,"depth":454,"text":574},{"id":588,"depth":448,"text":589,"children":1345},[1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359],{"id":592,"depth":454,"text":595},{"id":642,"depth":454,"text":645},{"id":840,"depth":454,"text":840},{"id":872,"depth":454,"text":872},{"id":920,"depth":454,"text":920},{"id":943,"depth":454,"text":946},{"id":970,"depth":454,"text":970},{"id":1026,"depth":454,"text":1026},{"id":1059,"depth":454,"text":1062},{"id":1102,"depth":454,"text":1102},{"id":1184,"depth":454,"text":1184},{"id":1212,"depth":454,"text":1212},{"id":1238,"depth":454,"text":1238},{"id":1282,"depth":454,"text":1282},"Sets of instants built from calendar points: arcs, unions, intersections, complements, and ordinal selection.","md",null,{},true,{"title":93,"description":1360},"vtHavqEFafCW4iSVJFiH0Spt_MmZMOkkFhaApDCw9zU",[1368,1370],{"title":89,"path":90,"stem":91,"description":1369,"children":-1},"Raised (or returned) when two points do not compose.",{"title":97,"path":98,"stem":99,"description":1371,"children":-1},"A directed span between two bounds of the same form, with per-side closings, a step, and an overflow policy.",1786065168174]