The Fuzion Language
LightNews LightNews
banner
fuzionlang.bsky.social
The Fuzion Language
@fuzionlang.bsky.social
3 followers 2 following 12 posts
A language that unifies concepts to improve productivity and to use tools for performance and correctness.
Posts Replies Media Videos
fuzionlang.bsky.social
The Fuzion October news are out.

We are making fast progress implementing the webserver behind fuzion-lang.dev to Fuzion.

On the Fuzion language, handling of lambdas and variadic type parameters and value argument is becoming more powerful.

All the details: fuzion-lang.dev/news/news_055
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
October 10, 2025 at 4:49 PM
fuzionlang.bsky.social
The Fuzion September news:

An efficient and type-safe mechanism for variable argument lists for functions is one of the exciting things we are working on.

All the details:

fuzion-lang.dev/news/news_054
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
September 9, 2025 at 1:06 PM
fuzionlang.bsky.social
The Fuzion August news:

Major news for the Fuzion language are support for loop correctness checking via loop invariants and faster static analysis.

Here are the details:

fuzion-lang.dev/news/news_053
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
August 18, 2025 at 10:41 AM
fuzionlang.bsky.social
The Fuzion July news:

Last month brought some nice language improvements for destructuring, nullary functions and automatic unwrapping together with a number of enhancements in the base library, bug fixes and code cleanup in the tools.

Here are the details:

fuzion-lang.dev/news/news_052
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
July 10, 2025 at 2:00 PM
fuzionlang.bsky.social
The Fuzion June news are out:

Progress on the foreign function interface is now demonstrated with an example calling the GTK toolkit.

Support for right associative operators make infix operation like piping to the left <| more natural.

Here are the details:

fuzion-lang.dev/news/news_051
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
June 17, 2025 at 1:25 PM
fuzionlang.bsky.social
The Fuzion May news are out:

Last month saw a large number of minor fixes in the Fuzion language, compiler and base library combined with some larger progress towards native library interfacing via value types and callbacks.

Here are the details:

fuzion-lang.dev/news/news_050
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
May 13, 2025 at 3:19 PM
fuzionlang.bsky.social
The Fuzion April news are out.

The focus shifted towards a Fuzion language improvements, generally turning experience we gain using Fuzion into language improvements. Meanwhile, important progress is happening on the native interface.

Here are the details:

fuzion-lang.dev/news/news_049
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
April 11, 2025 at 2:26 PM
fuzionlang.bsky.social
The Fuzion repository reached the milestone of 5000 issues / pull requests.

Fuzion is still in an experimental state, but it is moving ahead quickly!
Screenshot of github page showing three pull requests: ast: Fix position of inheritance calls generated for cotype, fix #5003 bug front end #5005 by fridis was merged Apr 3, 2025 • Approved lib: fix argument order inconsistency in scan and fold in Sequence base library cleanup #5004 by simonvonhackewitz was merged Apr 3, 2025 • Approved Fix 4992: Type constraint using.this results in error bug front end #5000 by fridis was merged Apr 3, 2025 • Approved
April 4, 2025 at 2:45 PM
fuzionlang.bsky.social
The Fuzion March news are out. Loads of minor cleanup and improvements are ongoing, while major work on improving the data flow analysis engine is on the way.

Here are the details:

fuzion-lang.dev/news/news_048
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
March 14, 2025 at 2:58 PM
fuzionlang.bsky.social
The February Fuzion news are out. A lot of work went into the stability of the Fuzion tools, in particular case of earlier errors and making the Fuzion intermediate representation more robuts.

Here are all the details:

fuzion-lang.dev/news/news_047
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
February 14, 2025 at 5:48 PM
Reposted by The Fuzion Language
fridis.bsky.social
A first version of the slides for my FOSDEM talk on effects for error handling in Fuzion are uploaded and I got onto my train just in time.

The examples can be modified and run interactively online:

fuzion-lang.dev/talks/fosdem...
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
January 31, 2025 at 2:12 PM
Reposted by The Fuzion Language
fridis.bsky.social
Just a week to go until @fosdem.bsky.social! Let me know if you are also there.
I will be in the Free Java dev room on Saturday.
Sunday, I will talk about effects for error handling in @fuzionlang.bsky.social in the Declarative and Minimalistic Languages devroom.
fosdem.org/2025/
FOSDEM 2025 - Home
fosdem.org
January 24, 2025 at 4:47 PM
fuzionlang.bsky.social
January Fuzion news are out. Progress on all fronts: From base lib work like easier meoization (one of many issues triggered by #AdventOfCode), fixes in the front end middle end down to native support for file io operations in all backends.

The details online:

fuzion-lang.dev/news/news_046
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
January 16, 2025 at 2:22 PM
fuzionlang.bsky.social
Very late with this month's Fuzion news, #AdventOfCode and the Holiday season kept us too busy.
Work focus was on performance of the fz tool, in particular DFA analysis, and loads of base library work applying effect handlers.
All the details:
fuzion-lang.dev/news/news_045
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev
December 27, 2024 at 8:56 PM
Reposted by The Fuzion Language
fridis.bsky.social
The Christmas Day's #AdventOfCode puzzle's solution took only three lines of logic using combine, zip, ∀ and count in @fuzionlang.bsky.social.

src: github.com/fridis/fuzio...

I am happy to have solved all 25 puzzles in Fuzion this year. The main goal was to improve Fuzion.

1/4
dec25 => input := io.stdin.read_string.split "\n\n" .map (.split "\n" .filter !="") counts(x) => (0..4).map (i -> x.map (.utf8[i]) .filter (="#".utf8[0]) .count) locks := input.filter (x -> x[0].starts_with "#") .map counts keys := input.filter (x -> x[0].starts_with ".") .map counts fits(l,k) => l.zip k (a,b -> a+b <= 6) ∀ id part1 => locks.combine keys fits .count id part2 => "Merry Christmas!" say "$part1:$part2"
December 26, 2024 at 1:28 PM
Reposted by The Fuzion Language
fridis.bsky.social
Late with yesterday's #AdventOfCode in @fuzionlang.bsky.social: A mixture of o-o and fp code: A parent `Wire` with abstract inner feature `state` and children `inpt` and `gate` that implement `state`.
Sneaked in monadic bind operators >>=, just for option.and_then.
srcs: github.com/fridis/fuzio...
dec24 => input := io.stdin.read_string.split "\n\n" .map (.split "\n" .filter !="") wires := (input[0].map (s -> s.split ": " |> (iw -> inpt iw[0] iw[1]="1")) .map Wire id ++ input[1].map (s -> s.split " " |> (ig -> gate ig[0] ig[1] ig[2] ig[4])) .map Wire id ) bits := wires.map (.name) .filter (.starts_with "z") .map (.replace "z" "" .parse_i64.val) .fold1 max device := container.ps_map String Wire .new (wires.map (.name)) wires # any wire coming from input or gate Wire(name String) ref is state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => abstract fix := mut 0 fix(n i32) => fix <- n+fix unfixed Sequence Wire => [] # input wire with given initial state inpt(redef name String, state bool) : Wire name is fix <- 1 redef state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => if x < 0 then state else b := name.substring 1 .parse_i64.val v := if name.starts_with "x" then x else if name.starts_with "y" then y else panic "x y expected $name" ((v >> b) & 1) != 0 # a logic gate gate(in1 String, op String, in2 String, redef name String) : Wire name is redef state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => if d > 100 then nil // we got into a cycle else get d+1 x y in1 >>= a-> get d+1 x y in2 >>= b-> if op = "AND" then a && b else if op = "OR" then a || b else if op = "XOR" then a ^ b else panic "unkown $op" redef fix(n i32) => fix <- n+fix wire in1 .fix n wire in2 .fix n redef unfixed Sequence Wire => if fix.get > 0 then [] else (wire in1 .unfixed ++ wire in2 .unfixed ++ [gate.this]) i64.z => "z"+(val.as_string 2 10) wire(name) => device[name].val # check if state of wire `name` is defined. # swap gives wi
December 25, 2024 at 10:33 PM
Reposted by The Fuzion Language
fridis.bsky.social
Dec 23 #AdventOfCode was a fun graph problem of finding cliques in graphs. My @fuzionlang.bsky.social defines types for vertices, edges and cliques to work with. To find the largest clique, it helped to start with smaller ones and add vertices one by one.
Sources: github.com/fridis/fuzio...
dec23 is # missing fuzion base lib functions: redef property.orderable.type.equality(a,b property.orderable.this) => a <= b <= a unique(sq Sequence (T : property.orderable)) => sq.reduce (id (container.Set T) (container.ps_set T).empty) (s,v -> s.add v) # types for vertex, edge and clique vertex(s) ref : property.orderable is fixed redef type.lteq( a,b dec23.vertex) => a.s <= b.s edges := lm.env.new (container.Set vertex) (container.ps_set vertex).empty edge(v,w) : property.orderable is v.edges <- v.edges.get.add w w.edges <- w.edges.get.add v fixed redef type.lteq(a,b dec23.edge) => !(b.v<=a.v) || a.v=b.v && a.w<=b.w clique(vs Sequence vertex) : property.orderable is fixed redef type.lteq(a,b dec23.clique) => a.as_string <= b.as_string get_edge(v,w) => if v < w then edge v w else edge w v get_vertex(s) : memoize => keep s _-> vertex s lm : mutate is lm ! ()-> input := io.stdin.read_lines.filter !="" .map s->(get_edge (get_vertex (s.substring 0 2)) (get_vertex (s.substring 3 5))) edges := input |> unique add_one(clique) => clique.vs.flat_map (e -> id (Sequence vertex) e.edges.get) .filter (v -> !clique.vs.contains v) |> sq->(unique sq) .filter (v -> clique.vs ∀ (.edges.get.contains v)) .map (v -> clique ([v] ++ clique.vs)) add_ones(cliques) => cliques.flat_map add_one .map (.vs.sort) .map clique |> unique largest(cliques) => n := add_ones cliques if n.is_empty then cliques else largest n part1 => edges.map e-> e.v.edges.get.filter x-> (x > e.w && e.w.edges.get.contains x && (e.v.s.starts_with "t" || e.w.s.starts_with "t" || x .s.starts_with "t" )) .count .fold1 (+) part2 => two_cliques := edges.map (e -> clique [e.v,e.w])
December 23, 2024 at 11:53 PM
Reposted by The Fuzion Language
fridis.bsky.social
After almost giving up, #AdventOfCode today was easier, but not trivial. Using memoization and arrays to speed up the code in @fuzionlang.bsky.social.
The sources on github: github.com/fridis/fuzio...
dec22 is input := io.stdin.read_lines.filter !="" .map (.parse_i64.val) .as_array next(s0 i64) => s2 := s0 ^ (s0 * 64) s3 := s2 % 16777216 s6 := (s3 ^ (s3 / 32)) % 16777216 (s6 ^ (s6 * 2048)) % 16777216 secrets(x) => x :: next prices(seed) : memoize => keep seed _-> secrets seed .map %10 .take 2001 .as_array changes(seed) : memoize => keep seed _-> prices seed .map (-) .map_pairs (-) .as_array part1 => input.map (seed -> secrets seed .drop 2000 .first.val) |> sum part2 => range => i64 -9 .. 9 n := input.count ns := 0..(n-1) cs := array n (i -> changes input[i]) # create array of array of indices of sequences that match currently # tested sequence up to index off. o is the previous array, v is the # value expected at current offset. # arr(o,off,v) => array n (i -> o[i].filter j->cs[i][j+off]=v .as_array) oa := array n _->(0..1996).as_array (range .map (a -> arr oa 0 a) .flat_map aa-> range .map (b -> arr aa 1 b) .flat_map ba-> range .map (c -> arr ba 2 c) .flat_map ca-> range.map d-> (ns.flat_map i64 i-> ca[i].filter (j -> cs[i][j+3] = d) .flat_map (j -> prices input[i] .drop j+4) .first ) |> sum ).fold1 max say "$part1:$part2"
December 22, 2024 at 8:55 PM
Reposted by The Fuzion Language
fridis.bsky.social
Almost gave up on yesterday's #AdventOfCode: First, I did not want to believe that taking different paths on the small keypads really would make a difference, got convinced after peeking into other's solutions.

Concise solution using effect-based memoziation APIs.

Src: github.com/fridis/fuzio...
dec21 is input := io.stdin.read_lines.filter !="" key(v codepoint) is # overlapping two layouts, put ` ` at (0,0) x => "741 <8520^v963AA>" .find v .val / 6 y => "789#456#123# 0^A<v>#".find v .val / 4 - 3 move_to(target key) => dx := target.x-x dy := target.y-y ve := ["^"," ","v"][dy.sign+1] * (|dy|) ho := ["<"," ",">"][dx.sign+1] * (|dx|) # I did not believe both paths make a difference for small keypad, # convinced by (or stole from) https://aoc.csokavar.hu/2024/21/ p1 := (target.y != 0 || x != 0).as_option String ve+ho+"A" p2 := (target.x != 0 || y != 0).as_option String ho+ve+"A" p1 ++ p2 find_shortest(d, l) i64 : memoize => keep "$d$l" _-> if d < 0 then l.byte_length.as_i64 else for res := i64 0, res + s prev := "A", cur cur in l.as_codepoints s := key prev .move_to (key cur) .map (find_shortest d-1) .fold1 min else res shortest(n) => lens := input.map (find_shortest n) numparts := input.map (.as_codepoints.filter (c -> "0" <= c <= "9") .reduce "" (+) .parse_i64.val) lens.zip numparts (*) |> sum part1 => shortest 2 part2 => shortest 25 say "$part1:$part2"
December 22, 2024 at 2:03 PM
Reposted by The Fuzion Language
fridis.bsky.social
Dec 20 #AdventOfCode reading comprehension exercise: A feature point with many inner helper features, including infix + and - operators helped to create a clean solution in @fuzionlang.bsky.social .
The sources: github.com/fridis/fuzio...
dec20 => minsaving := envir.args[1].parse_i32.val input := io.stdin.read_lines.filter !="" .map (.as_codepoints) w := input[0].count h := input.count area := array2 w h x,y->input[y][x] point(x,y) is xl => x.as_i64 yl => y.as_i64 neighbors => [up, dw, le, ri].filter (.valid) valid => 0 <= x < w && 0 <= y < h on_track => valid && area[x,y] != "#" inner_wall => 1 <= x < w-1 && 1 <= y < h-1 && !on_track abs => (|x|) + (|y|) infix + (o) => point x+o.x y+o.y infix - (o) => point x-o.x y-o.y up => { point x y-1}; dw => { point x y+1 } le => { point x-1 y}; ri => { point x+1 y } s := area.index_pairs.filter (||> y,x->area[y,x]="S") .first.val ||> point M : mutate is M ! ()-> track := (mutate.array point).type.new M picos := (mutate.array2 i32).type.new M w.as_i64 h.as_i64 -1 picos(p) => picos[p.xl,p.yl] for p := s, p.neighbors.filter (.on_track) .filter q->picos[q.xl,q.yl]<0 .first.val ps := 0, ps+1 do picos[p.xl,p.yl] := ps track.add p until area[p.x,p.y] = "E" unit part1 => saving(p) => t := picos p.up; b := picos p.dw l := picos p.le; r := picos p.ri if t>=0 && b>=0 then (|t-b|)-2 else if l>=0 && r>=0 then (|l-r|)-2 else 0 area.index_pairs.map ||>point .filter (.inner_wall) .map saving .filter >=minsaving .count part2 => range := -20 .. 20 track.as_array.flat_map pi-> range.combine range point .filter (p -> p.abs <= 20) .map (pi+) .filter (.on_track) .map (pj -> picos pj - picos pi - (pj-pi).abs) .filter >=minsaving .count say "$part1:$part2"
December 21, 2024 at 9:48 AM
Reposted by The Fuzion Language
fridis.bsky.social
Happy about a clean @fuzionlang.bsky.social solution for today's #AdventOfCode challenge: arranging towels to match designs. Caches did the trick.

A nice gimmick: Added a new feature `suffix` to be called on `String`, just to make the code a little cleaner.

The source: github.com/fridis/fuzio...
dec19 => input := io.stdin.read_lines towels := input[0].split ", " .as_array designs := input.drop 2 .filter !="" String.suffix(prfx) => substring prfx.byte_length M : mutate is M ! ()-> cachePos := (container.mutable_tree_map M String bool).empty cacheCnt := (container.mutable_tree_map M String i64 ).empty possible(s) => match cachePos.get s v bool => v nil => res := s="" || !towels.filter s.starts_with .map s.suffix .filter possible .is_empty cachePos.put s res res count(s) => match cacheCnt.get s v i64 => v nil => res := s="" ? 1 : towels.filter s.starts_with .map s.suffix .map count |> sum cacheCnt.put s res res part1 => designs.filter possible .count part2 => designs.map count |> sum say "$part1:$part2"
December 19, 2024 at 8:56 PM
Reposted by The Fuzion Language
fridis.bsky.social
Dec 18 #AdventOfCode started with a path search in a maze. In part 2, the maze gradually becomes denser until unsolvable. In my solution in @fuzionlang.bsky.social, instead of re-solving each maze, I track walls from bottom/left and top/right until they connect.
src: github.com/fridis/fuzio...
dec18 => wi := envir.args[1].parse_i32.val w := wi.as_i64 inside(x) => 0 <= x < w l := envir.args[2].parse_i32.val input2 := io.stdin.read_lines.filter !="" .map (.split "," .map s->s.parse_i64.val) .map s->(s[0],s[1]) input1 := input2.map (||>x,y->(x.as_i32,y.as_i32)) .take l .as_array lm : mutate is lm ! ()-> part1 => area := array2 wi wi (x,y -> (input1 ∃ t -> t.0=x && t.1=y)) corrupt(x,y) => area[x.as_i32,y.as_i32] mcost := (mutate.array2 i32).type.new lm w w i32.max trace(x,y i64, cost i32) => if inside x && inside y && cost < mcost[x, y] && !corrupt x y mcost[x, y] := cost trace x+1 y cost+1; trace x y+1 cost+1 trace x-1 y cost+1; trace x y-1 cost+1 trace 0 0 0 mcost[w-1, w-1] part2 => area := (mutate.array2 bool).type.new lm w w false leftbot := (mutate.array2 bool).type.new lm w w false toprite := (mutate.array2 bool).type.new lm w w false for cor in input2 do (x,y) := cor area[x,y] := true fill leftbot x y (x=0 || y=w-1) fill toprite x y (y=0 || x=w-1) get(a,xx,yy) => inside xx && inside yy && a[xx,yy] get(a,xy) => xy ||> get a box(xx,yy) => ((xx-1)..(xx+1)).combine (yy-1)..(yy+1) x0,y0->(x0,y0) fill(a,xx,yy,touches) => if ((touches || (box x y ∃ get a)) && get area xx yy && !a[xx,yy]) a[xx,yy] := true box xx yy .for_each (||> dx,dy -> fill a dx dy true) until leftbot[x,y] && toprite[x,y] then "$x,$y" else "never" say "$part1:$part2"
December 19, 2024 at 9:51 AM
Reposted by The Fuzion Language
fridis.bsky.social
Had fun with today's #AdventOfCode in @fuzionlang.bsky.social:

Part1 An interpreter for machine code, managed to use only pure functions.

Part2 is hacky, basically guessing input 3 bits at a time. Almost tried to change the dir of time in the part 1 interperter.

src github.com/fridis/fuzio...
dec17 => input := io.stdin.read_lines get(prefx) => input.filter (.starts_with prefx) .first.val.replace prefx "" initial_A := get "Register A: " .parse_i64.val initial_B := get "Register B: " .parse_i64.val initial_C := get "Register C: " .parse_i64.val code := get "Program: " .split "," .map (.parse_i64.val) .as_array regs(a,b,c,pc,out) is ins => code[pc].as_i32 op => code[pc+1] combo => if op < 4 then op else if op = 4 then a else if op = 5 then b else if op = 6 then c else panic "reserved op $op" div => a >> combo exec array regs->regs := [s -> regs s.div s.b s.c s.pc+2 s.out , s -> regs s.a s.b^s.op s.c s.pc+2 s.out , s -> regs s.a s.combo%8 s.c s.pc+2 s.out , s -> regs s.a s.b s.c s.a=0?s.pc+2:s.op.as_i32 s.out , s -> regs s.a s.b^s.c s.c s.pc+2 s.out , s -> regs s.a s.b s.c s.pc+2 s.out++[s.combo%8], s -> regs s.a s.div s.c s.pc+2 s.out , s -> regs s.a s.b s.div s.pc+2 s.out ] run(s) => if 0 <= s.pc < code.length then run (exec[s.ins].call s) else s.out runa(a) => run (regs a initial_B initial_C 0 (id (Sequence i64) [])) part1 => (runa initial_A).as_string "," part2 => for i := 15, i-1 delta := i64 0o1000000000000000, delta / 8 a := i64 0, new_a while delta > 0 new_a := for na := a, na + delta until (runa na).drop i = code.drop i then na else a say "$part1:$part2"
December 17, 2024 at 9:18 PM
Reposted by The Fuzion Language
fridis.bsky.social
Today's #AdventOfCode was a fairly standard shortest path finding in a 2D grid, but it turned out to actually be 3D since turning has a hefty extra cost.
Here my solution in @fuzionlang.bsky.social on github: github.com/fridis/fuzio...
dec16 => input := io.stdin.read_string.split "\n" .as_array .filter !="" .map (.as_codepoints) .as_array h := input.count w := input[0].count area := array2 codepoint h w y,x->input[y][x] point(y,x) is mov(d) => if d=0 then point y-1 x else if d=1 then point y x-1 else if d=2 then point y+1 x else point y x+1 e := area.index_pairs.filter (||> y,x->area[y,x]="E") .first.val ||> point s := area.index_pairs.filter (||> y,x->area[y,x]="S") .first.val ||> point cost_of_turns(d1,d2) => if (d1 = d2) then 0 else if (d1 = (d2+2)%4) then 2000 else 1000 lm : mutate is costs := lm ! ()-> mcosts := array2 4 h s,y-> (mutate.array i32).type.new lm w.as_i64 i32.max trace(d, p, cost) => if cost < mcosts[d,p.y][p.x.as_i64] then mcosts[d,p.y][p.x.as_i64] := cost # try to move p2 := p.mov (d+2)%4 if ("#" != area[p2.y,p2.x] && cost+1 < mcosts[d,p2.y][p2.x.as_i64] && cost+1 < mcosts[3,s .y][s .x.as_i64] ) then trace d p2 cost+1 # try to turn (1..3).for_each dd-> trace (d+dd)%4 p (cost + cost_of_turns 0 dd) # trace costs backwards starting at e (0..3).for_each (d -> trace d e 0) array2 4 h ss,yy->mcosts[ss,yy].as_array cost(d,p) => costs[d,p.y][p.x]; part1 => cost 3 s part2 => lm ! ()-> paths := (mutate.array2 bool).type.new lm h.as_i64 w.as_i64 false mark(d, p) => if !paths[p.y.as_i64, p.x.as_i64] then paths[ p.y.as_i64, p.x.as_i64] := true if cost 0 p != 0 min_cst(dd) => cost dd (p.mov dd) +^ cost_of_turns dd d cmin := (0..3).map min_cst .reduce i32.max min (0..3).for_each dd-> if min_cst dd = cmin then mark dd (p.mov dd) mark 3 s paths.as_array.filter id .count say "$part1
December 16, 2024 at 9:58 PM
Reposted by The Fuzion Language
fridis.bsky.social
Today's #AdventOfCode in @fuzionlang.bsky.social requires memoization / caching of results. Since caching a value performs a state change, we need a mutate effect. We use a local mutate `M` in our `blink` function that itself remains pure.
The sources on github: github.com/fridis/fuzio...
dec11 => input := io.stdin.read_string data := input.trim.split " " .map (.parse_i64.val) blink(b i64) => M : mutate is M ! ()-> cache := (container.mutable_tree_map M i64 i64).empty count(i, n) i64 ! M => k := i << 50 | n; match cache[k] nil => l := ($n).byte_length.as_i64 res := if i=0 then 1 else if n=0 then count i-1 1 else if l %% 2 then f := (i64 10)**(l/2); count i-1 n/f + count i-1 n%f else count i-1 n*2024 cache.put k res res r i64 => r data.map (count b) |> sum part1 => blink 25 part2 => blink 75 say "$part1,$part2"
December 11, 2024 at 4:13 PM