humza/sml-projects
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

formatting for persistent-vector.sml (absolutely no changes other than formatting)

Browse Source
This commit is contained in:
Humza Shahid
2025-12-08 22:40:38 +00:00
parent 2ba18a38b0
commit d52c350a90
1 changed files with 343 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
fcore/persistent-vector.sml
View File

@@ -104,10 +104,7 @@ struct
val prevFinish = Vector.sub (sizes, Vector.length sizes - 1) val prevFinish = Vector.sub (sizes, Vector.length sizes - 1)
val start = start - prevFinish val start = start - prevFinish
val finish = finish - prevFinish val finish = finish - prevFinish
val newNode = LEAF val newNode = LEAF (#[{start = start, finish = finish}], #[finish])
( #[{start = start, finish = finish}]
, #[finish]
)
in in
APPEND newNode APPEND newNode
end end
@@ -125,11 +122,8 @@ struct
case helpAppend (start, finish, tree) of case helpAppend (start, finish, tree) of
UPDATE t => t UPDATE t => t
| APPEND newNode => | APPEND newNode =>
let let val maxSize = getFinishIdx tree
val maxSize = getFinishIdx tree in BRANCH (#[tree, newNode], #[maxSize, finish])
in
BRANCH
(#[tree, newNode], #[maxSize, finish])
end end
fun getStart tree = fun getStart tree =
@@ -350,10 +344,8 @@ struct
case tree of case tree of
BRANCH (nodes, _) => getFirstItem (Vector.sub (nodes, 0)) BRANCH (nodes, _) => getFirstItem (Vector.sub (nodes, 0))
| LEAF (items, _) => | LEAF (items, _) =>
if Vector.length items = 0 then if Vector.length items = 0 then {start = ~1, finish = ~1}
{start = ~1, finish = ~1} else Vector.sub (items, 0)
else
Vector.sub (items, 0)
fun getMaxSize tree = fun getMaxSize tree =
case tree of case tree of
@@ -372,9 +364,8 @@ struct
Vector.sub (sizes, Vector.length sizes - 1) Vector.sub (sizes, Vector.length sizes - 1)
else else
0 0
val result = val result = splitLeft (offset - prevSize, Vector.sub
splitLeft (nodes, Vector.length nodes - 1))
(offset - prevSize, Vector.sub (nodes, Vector.length nodes - 1))
in in
if isEmpty result then if isEmpty result then
let let
@@ -389,8 +380,10 @@ struct
else else
let let
val newChildSize = getMaxSize result + prevSize val newChildSize = getMaxSize result + prevSize
val sizes = Vector.update (sizes, Vector.length sizes - 1, newChildSize) val sizes = Vector.update
val nodes = Vector.update (nodes, Vector.length nodes - 1, result) (sizes, Vector.length sizes - 1, newChildSize)
val nodes = Vector.update
(nodes, Vector.length nodes - 1, result)
in in
BRANCH (nodes, sizes) BRANCH (nodes, sizes)
end end
@@ -398,11 +391,7 @@ struct
else else
let let
val idx = BinSearch.equalOrMore (offset, sizes) val idx = BinSearch.equalOrMore (offset, sizes)
val prevSize = val prevSize = if idx > 1 then Vector.sub (sizes, idx - 1) else 0
if idx > 1 then
Vector.sub (sizes, idx - 1)
else
0
val result = splitLeft (offset - prevSize, Vector.sub (nodes, idx)) val result = splitLeft (offset - prevSize, Vector.sub (nodes, idx))
in in
if isEmpty result then if isEmpty result then
@@ -418,20 +407,11 @@ struct
else else
let let
val len = idx + 1 val len = idx + 1
val sizes = Vector.tabulate (len, val sizes = Vector.tabulate (len, fn i =>
fn i => if i = idx then getMaxSize result + prevSize
if i = idx then else Vector.sub (sizes, i))
getMaxSize result + prevSize val nodes = Vector.tabulate (len, fn i =>
else if i = idx then result else Vector.sub (nodes, i))
Vector.sub (sizes, i)
)
val nodes = Vector.tabulate (len,
fn i =>
if i = idx then
result
else
Vector.sub (nodes, i)
)
in in
BRANCH (nodes, sizes) BRANCH (nodes, sizes)
end end
@@ -474,7 +454,8 @@ struct
val len = Vector.length sizes - 1 val len = Vector.length sizes - 1
val sizeSlice = VectorSlice.slice (sizes, 1, SOME len) val sizeSlice = VectorSlice.slice (sizes, 1, SOME len)
val sizes = VectorSlice.map (fn el => el - firstSizeBefore) sizeSlice val sizes =
VectorSlice.map (fn el => el - firstSizeBefore) sizeSlice
val nodeSlice = VectorSlice.slice (nodes, 1, SOME len) val nodeSlice = VectorSlice.slice (nodes, 1, SOME len)
val nodes = VectorSlice.vector nodeSlice val nodes = VectorSlice.vector nodeSlice
@@ -486,12 +467,10 @@ struct
val firstSizeAfter = getMaxSize result val firstSizeAfter = getMaxSize result
val sizeDiff = firstSizeBefore - firstSizeAfter val sizeDiff = firstSizeBefore - firstSizeAfter
val sizes = Vector.mapi (fn (idx, el) => val sizes =
if idx = 0 then Vector.mapi
firstSizeAfter (fn (idx, el) =>
else if idx = 0 then firstSizeAfter else el - sizeDiff) sizes
el - sizeDiff
) sizes
val nodes = Vector.update (nodes, 0, result) val nodes = Vector.update (nodes, 0, result)
in in
@@ -547,11 +526,7 @@ struct
val len = Vector.length sizes - idx val len = Vector.length sizes - idx
val len = SOME len val len = SOME len
val prevSize = val prevSize = if idx < 1 then 0 else Vector.sub (sizes, idx - 1)
if idx < 1 then
0
else
Vector.sub (sizes, idx - 1)
val sizes = VectorSlice.slice (sizes, idx, len) val sizes = VectorSlice.slice (sizes, idx, len)
val sizes = VectorSlice.map (fn i => i - prevSize) sizes val sizes = VectorSlice.map (fn i => i - prevSize) sizes
@@ -559,8 +534,7 @@ struct
val items = val items =
VectorSlice.map VectorSlice.map
(fn {start, finish} => (fn {start, finish} =>
{start = start - prevSize, finish = finish - prevSize}) {start = start - prevSize, finish = finish - prevSize}) items
items
in in
LEAF (items, sizes) LEAF (items, sizes)
end end
@@ -581,9 +555,10 @@ struct
let let
val nodes = Vector.concat [leftNodes, rightNodes] val nodes = Vector.concat [leftNodes, rightNodes]
val maxLeftSize = Vector.sub (leftSizes, Vector.length leftSizes - 1) val maxLeftSize = Vector.sub (leftSizes, Vector.length leftSizes - 1)
val sizes = Vector.tabulate val sizes =
(Vector.length leftSizes + Vector.length rightSizes, Vector.tabulate
fn i => ( Vector.length leftSizes + Vector.length rightSizes
, fn i =>
if i < Vector.length leftSizes then if i < Vector.length leftSizes then
Vector.sub (leftSizes, i) Vector.sub (leftSizes, i)
else else
@@ -597,31 +572,27 @@ struct
let let
val maxLeftSize = Vector.sub (leftSizes, Vector.length leftSizes - 1) val maxLeftSize = Vector.sub (leftSizes, Vector.length leftSizes - 1)
val len = Vector.length leftItems + Vector.length rightItems val len = Vector.length leftItems + Vector.length rightItems
val items = val items = Vector.tabulate (len, fn i =>
Vector.tabulate (len,
fn i =>
if i < Vector.length leftItems then if i < Vector.length leftItems then
Vector.sub (leftItems, i) Vector.sub (leftItems, i)
else else
let let
val {start, finish} = Vector.sub (rightItems, i - Vector.length leftItems) val {start, finish} = Vector.sub
(rightItems, i - Vector.length leftItems)
in in
{start = start + maxLeftSize, finish = finish + maxLeftSize} {start = start + maxLeftSize, finish = finish + maxLeftSize}
end end)
) val sizes = Vector.tabulate (len, fn i =>
val sizes =
Vector.tabulate (len,
fn i =>
if i < Vector.length leftSizes then if i < Vector.length leftSizes then
Vector.sub (leftSizes, i) Vector.sub (leftSizes, i)
else else
Vector.sub (rightSizes, i - Vector.length leftSizes) Vector.sub (rightSizes, i - Vector.length leftSizes) + maxLeftSize)
+ maxLeftSize
)
in in
LEAF (items, sizes) LEAF (items, sizes)
end end
| _ => raise Fail "PersistentVector.joinSameDepth: one is BRANCH and other is LEAF" | _ =>
raise Fail
"PersistentVector.joinSameDepth: one is BRANCH and other is LEAF"
datatype append_join_result = datatype append_join_result =
APPEND_JOIN_APPEND of t APPEND_JOIN_APPEND of t
@@ -640,15 +611,14 @@ struct
let let
val nodes = Vector.concat [nodes, rightNodes] val nodes = Vector.concat [nodes, rightNodes]
val lastLeftSize = Vector.sub (sizes, Vector.length sizes - 1) val lastLeftSize = Vector.sub
val sizes = Vector.tabulate (Vector.length nodes, (sizes, Vector.length sizes - 1)
fn i => val sizes = Vector.tabulate (Vector.length nodes, fn i =>
if i < Vector.length sizes then if i < Vector.length sizes then
Vector.sub (sizes, i) Vector.sub (sizes, i)
else else
Vector.sub (rightSizes, i - Vector.length sizes) Vector.sub (rightSizes, i - Vector.length sizes)
+ lastLeftSize + lastLeftSize)
)
in in
APPEND_JOIN_UPDATE (BRANCH (nodes, sizes)) APPEND_JOIN_UPDATE (BRANCH (nodes, sizes))
end end
@@ -656,8 +626,7 @@ struct
raise Fail raise Fail
"persistent-vector.sml appendJoin: \ "persistent-vector.sml appendJoin: \
\expected to join when left and right are both BRANCH \ \expected to join when left and right are both BRANCH \
\but left is BRANCH and right is LEAF" \but left is BRANCH and right is LEAF")
)
else else
(* recursion case: join below *) (* recursion case: join below *)
let let
@@ -668,8 +637,7 @@ struct
APPEND_JOIN_UPDATE newLast => APPEND_JOIN_UPDATE newLast =>
let let
val prevSize = val prevSize =
if lastIdx > 0 then Vector.sub (sizes, lastIdx - 1) if lastIdx > 0 then Vector.sub (sizes, lastIdx - 1) else 0
else 0
val newLastSize = getMaxSize newLast + prevSize val newLastSize = getMaxSize newLast + prevSize
val sizes = Vector.update (sizes, lastIdx, newLastSize) val sizes = Vector.update (sizes, lastIdx, newLastSize)
val nodes = Vector.update (nodes, lastIdx, newLast) val nodes = Vector.update (nodes, lastIdx, newLast)
@@ -680,11 +648,11 @@ struct
if Vector.length nodes = maxSize then if Vector.length nodes = maxSize then
(* parent has to append insead as this node (* parent has to append insead as this node
* would exceed capacity if appended here *) * would exceed capacity if appended here *)
APPEND_JOIN_APPEND (BRANCH (#[newNode], #[getMaxSize newNode])) APPEND_JOIN_APPEND (BRANCH
(#[newNode], #[getMaxSize newNode]))
else else
let let
val prevSize = val prevSize = Vector.sub (sizes, Vector.length sizes - 1)
Vector.sub (sizes, Vector.length sizes - 1)
val newNodeSize = #[getMaxSize newNode + prevSize] val newNodeSize = #[getMaxSize newNode + prevSize]
val sizes = Vector.concat [sizes, newNodeSize] val sizes = Vector.concat [sizes, newNodeSize]
@@ -705,25 +673,24 @@ struct
val leftMaxSize = Vector.sub (sizes, Vector.length sizes - 1) val leftMaxSize = Vector.sub (sizes, Vector.length sizes - 1)
val newLen = Vector.length items + Vector.length rightItems val newLen = Vector.length items + Vector.length rightItems
val items = Vector.tabulate (newLen, val items = Vector.tabulate (newLen, fn i =>
fn i =>
if i < Vector.length items then if i < Vector.length items then
Vector.sub (items, i) Vector.sub (items, i)
else else
let let
val {start, finish} = Vector.sub (rightItems, i - Vector.length items) val {start, finish} = Vector.sub
(rightItems, i - Vector.length items)
in in
{start = start + leftMaxSize, finish = finish + leftMaxSize} { start = start + leftMaxSize
end , finish = finish + leftMaxSize
) }
val sizes = Vector.tabulate (newLen, end)
fn i => val sizes = Vector.tabulate (newLen, fn i =>
if i < Vector.length sizes then if i < Vector.length sizes then
Vector.sub (sizes, i) Vector.sub (sizes, i)
else else
Vector.sub (rightSizes, i - Vector.length sizes) Vector.sub (rightSizes, i - Vector.length sizes)
+ leftMaxSize + leftMaxSize)
)
in in
APPEND_JOIN_UPDATE (LEAF (items, sizes)) APPEND_JOIN_UPDATE (LEAF (items, sizes))
end end
@@ -731,8 +698,7 @@ struct
raise Fail raise Fail
"persistent-vector.sml appendJoin: \ "persistent-vector.sml appendJoin: \
\left is LEAF and expected right to also be LEAF \ \left is LEAF and expected right to also be LEAF \
\but right is BRANCH" \but right is BRANCH")
)
datatype prepend_join_result = datatype prepend_join_result =
PREPEND_JOIN_PREPEND of t PREPEND_JOIN_PREPEND of t
@@ -750,16 +716,14 @@ struct
BRANCH (leftNodes, leftSizes) => BRANCH (leftNodes, leftSizes) =>
let let
val nodes = Vector.concat [leftNodes, rightNodes] val nodes = Vector.concat [leftNodes, rightNodes]
val maxLeftSize = val maxLeftSize = Vector.sub
Vector.sub (leftSizes, Vector.length leftSizes - 1) (leftSizes, Vector.length leftSizes - 1)
val sizes = Vector.tabulate (Vector.length nodes, val sizes = Vector.tabulate (Vector.length nodes, fn i =>
fn i =>
if i < Vector.length leftSizes then if i < Vector.length leftSizes then
Vector.sub (leftSizes, i) Vector.sub (leftSizes, i)
else else
Vector.sub (rightSizes, i - Vector.length leftSizes) Vector.sub (rightSizes, i - Vector.length leftSizes)
+ maxLeftSize + maxLeftSize)
)
in in
PREPEND_JOIN_UPDATE (BRANCH (nodes, sizes)) PREPEND_JOIN_UPDATE (BRANCH (nodes, sizes))
end end
@@ -767,8 +731,7 @@ struct
raise Fail raise Fail
"persistent-vector.sml prependJoin: \ "persistent-vector.sml prependJoin: \
\expected left and right to be BRANCH \ \expected left and right to be BRANCH \
\but right is BRANCH while left is LEAF" \but right is BRANCH while left is LEAF")
)
else else
(* recursive case *) (* recursive case *)
let let
@@ -787,19 +750,16 @@ struct
end end
| PREPEND_JOIN_PREPEND newFirst => | PREPEND_JOIN_PREPEND newFirst =>
if Vector.length rightSizes = maxSize then if Vector.length rightSizes = maxSize then
PREPEND_JOIN_PREPEND (BRANCH (#[newFirst], #[getMaxSize newFirst])) PREPEND_JOIN_PREPEND (BRANCH
(#[newFirst], #[getMaxSize newFirst]))
else else
let let
val nodes = Vector.concat [#[newFirst], rightNodes] val nodes = Vector.concat [#[newFirst], rightNodes]
val newFirstSize = getMaxSize newFirst val newFirstSize = getMaxSize newFirst
val sizes = Vector.tabulate (Vector.length nodes, val sizes = Vector.tabulate (Vector.length nodes, fn i =>
fn i => if i = 0 then newFirstSize
if i = 0 then else Vector.sub (rightSizes, i - 1) + newFirstSize)
newFirstSize
else
Vector.sub (rightSizes, i - 1) + newFirstSize
)
in in
PREPEND_JOIN_UPDATE (BRANCH (nodes, sizes)) PREPEND_JOIN_UPDATE (BRANCH (nodes, sizes))
end) end)
@@ -812,27 +772,27 @@ struct
(case left of (case left of
LEAF (leftItems, leftSizes) => LEAF (leftItems, leftSizes) =>
let let
val maxLeftSize = Vector.sub (leftSizes, Vector.length leftSizes - 1) val maxLeftSize = Vector.sub
(leftSizes, Vector.length leftSizes - 1)
val len = Vector.length leftSizes + Vector.length rightItems val len = Vector.length leftSizes + Vector.length rightItems
val sizes = Vector.tabulate (len, val sizes = Vector.tabulate (len, fn i =>
fn i =>
if i < Vector.length leftSizes then if i < Vector.length leftSizes then
Vector.sub (leftSizes, i) Vector.sub (leftSizes, i)
else else
Vector.sub (rightSizes, i - Vector.length leftSizes) Vector.sub (rightSizes, i - Vector.length leftSizes)
+ maxLeftSize) + maxLeftSize)
val items = Vector.tabulate (len, val items = Vector.tabulate (len, fn i =>
fn i =>
if i < Vector.length leftItems then if i < Vector.length leftItems then
Vector.sub (leftItems, i) Vector.sub (leftItems, i)
else else
let let
val {start, finish} = val {start, finish} = Vector.sub
Vector.sub (rightItems, i - Vector.length leftItems) (rightItems, i - Vector.length leftItems)
in in
{start = start + maxLeftSize, finish = finish + maxLeftSize} { start = start + maxLeftSize
end , finish = finish + maxLeftSize
) }
end)
in in
PREPEND_JOIN_UPDATE (LEAF (items, sizes)) PREPEND_JOIN_UPDATE (LEAF (items, sizes))
end end