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

formatting for fcore/persistent-vector.sml

Browse Source
This commit is contained in:
Humza Shahid
2025-12-03 11:06:08 +00:00
parent 0625c33bec
commit 237d9f8a38
1 changed files with 141 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
fcore/persistent-vector.sml
View File

@@ -32,10 +32,8 @@ struct
else if searchIdx = 0 then else if searchIdx = 0 then
isInRange (checkIdx, Vector.sub (nodes, searchIdx)) isInRange (checkIdx, Vector.sub (nodes, searchIdx))
else else
let let val nextCheckIdx = checkIdx - Vector.sub (sizes, searchIdx - 1)
val nextCheckIdx = checkIdx - Vector.sub (sizes, searchIdx - 1) in isInRange (nextCheckIdx, Vector.sub (nodes, searchIdx))
in
isInRange (nextCheckIdx, Vector.sub (nodes, searchIdx))
end end
end end
| LEAF (values, sizes) => | LEAF (values, sizes) =>
@@ -45,10 +43,8 @@ struct
if searchIdx = ~1 then if searchIdx = ~1 then
false false
else else
let let val {start, finish} = Vector.sub (values, searchIdx)
val {start, finish} = Vector.sub (values, searchIdx) in checkIdx >= start andalso checkIdx <= finish
in
checkIdx >= start andalso checkIdx <= finish
end end
end end
@@ -80,12 +76,14 @@ struct
end end
| APPEND newVec => | APPEND newVec =>
if Vector.length nodes = maxSize then if Vector.length nodes = maxSize then
let let
(* adjust "finish" so that it does not consider (* adjust "finish" so that it does not consider
* offset for "lower" vector *) * offset for "lower" vector *)
val finish = finish - Vector.sub (sizes, Vector.length sizes - 1) val finish =
val newNode = BRANCH (#[newVec], #[finish]) finish - Vector.sub (sizes, Vector.length sizes - 1)
in val newNode = BRANCH
(#[newVec], #[finish])
in
APPEND newNode APPEND newNode
end end
else else
@@ -103,12 +101,15 @@ struct
* we want to adjust the start and finish parameters * we want to adjust the start and finish parameters
* so that they don't contain the offset relevant to the * so that they don't contain the offset relevant to the
* "lower" vector, which was split from *) * "lower" vector, which was split from *)
let let
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 (#[{start = start, finish = finish}], #[finish]) val newNode = LEAF
in ( #[{start = start, finish = finish}]
, #[finish]
)
in
APPEND newNode APPEND newNode
end end
else else
@@ -124,11 +125,12 @@ struct
fun append (start, finish, tree) = fun append (start, finish, tree) =
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 in
BRANCH (#[tree, newNode], #[maxSize, finish]) BRANCH
(#[tree, newNode], #[maxSize, finish])
end end
fun getStart tree = fun getStart tree =
@@ -142,26 +144,22 @@ struct
let let
val idx = BinSearch.equalOrMore (cursorIdx, sizes) val idx = BinSearch.equalOrMore (cursorIdx, sizes)
in in
if idx = ~1 then {start = ~1, finish = ~1} if idx = ~1 then
else {start = ~1, finish = ~1}
let else
val {start, finish} = Vector.sub (values, idx) let val {start, finish} = Vector.sub (values, idx)
in in {start = start + acc, finish = finish + acc}
{start = start + acc, finish = finish + acc}
end end
end end
| BRANCH (nodes, sizes) => | BRANCH (nodes, sizes) =>
let let
val idx = BinSearch.equalOrMore (cursorIdx, sizes) val idx = BinSearch.equalOrMore (cursorIdx, sizes)
in in
if idx = ~1 then {start = ~1, finish = ~1} if idx = ~1 then
else {start = ~1, finish = ~1}
else
let let
val prevSize = val prevSize = if idx = 0 then 0 else Vector.sub (sizes, idx - 1)
if idx = 0 then
0
else
Vector.sub (sizes, idx - 1)
val acc = acc + prevSize val acc = acc + prevSize
val cursorIdx = cursorIdx - prevSize val cursorIdx = cursorIdx - prevSize
in in
@@ -185,14 +183,11 @@ struct
let let
val idx = BinSearch.equalOrMore (cursorIdx, sizes) val idx = BinSearch.equalOrMore (cursorIdx, sizes)
in in
if idx = ~1 then {start = ~1, finish = ~1} if idx = ~1 then
else {start = ~1, finish = ~1}
else
let let
val prevSize = val prevSize = if idx = 0 then 0 else Vector.sub (sizes, idx - 1)
if idx = 0 then
0
else
Vector.sub (sizes, idx - 1)
val cursorIdx = cursorIdx - prevSize val cursorIdx = cursorIdx - prevSize
in in
helpNextMatch (cursorIdx, Vector.sub (nodes, idx), prevSize) helpNextMatch (cursorIdx, Vector.sub (nodes, idx), prevSize)
@@ -225,23 +220,20 @@ struct
let val {start, finish} = getStart tree let val {start, finish} = getStart tree
in loopNextMatch (start, finish, tree, count - 1) in loopNextMatch (start, finish, tree, count - 1)
end end
else
let
in
if cursorIdx >= start andalso cursorIdx <= finish then
loopNextMatch (start, finish, tree, count)
else else
loopNextMatch (start, finish, tree, count - 1) let in
if cursorIdx >= start andalso cursorIdx <= finish then
loopNextMatch (start, finish, tree, count)
else
loopNextMatch (start, finish, tree, count - 1)
end end
end end
fun getLast (tree, acc) = fun getLast (tree, acc) =
case tree of case tree of
LEAF (values, _) => LEAF (values, _) =>
let let val {start, finish} = Vector.sub (values, Vector.length values - 1)
val {start, finish} = Vector.sub (values, Vector.length values - 1) in {start = start + acc, finish = finish + acc}
in
{start = start + acc, finish = finish + acc}
end end
| BRANCH (nodes, sizes) => | BRANCH (nodes, sizes) =>
let let
@@ -281,9 +273,10 @@ struct
let let
val result = Vector.sub (values, 0) val result = Vector.sub (values, 0)
in in
if #start result < cursorIdx then if #start result < cursorIdx then
{start = #start result + acc, finish = #finish result + acc} {start = #start result + acc, finish = #finish result + acc}
else {start = ~1, finish = ~1} else
{start = ~1, finish = ~1}
end end
else else
let let
@@ -307,19 +300,18 @@ struct
let let
val node = Vector.sub (nodes, idx) val node = Vector.sub (nodes, idx)
val prevSize = Vector.sub (sizes, idx - 1) val prevSize = Vector.sub (sizes, idx - 1)
val result = helpPrevMatch (cursorIdx - prevSize, node, acc + prevSize) val result =
helpPrevMatch (cursorIdx - prevSize, node, acc + prevSize)
in in
if #start result = ~1 then if #start result = ~1 then
let let
val prevPrevSize = val prevPrevSize =
if idx - 2 < 0 then if idx - 2 < 0 then 0 else Vector.sub (sizes, idx - 2)
0
else
Vector.sub (sizes, idx - 2)
in in
getLast (Vector.sub (nodes, idx - 1), acc + prevPrevSize) getLast (Vector.sub (nodes, idx - 1), acc + prevPrevSize)
end end
else result else
result
end end
end end
@@ -358,7 +350,9 @@ struct
(* todo: modify below functions so that they also (* todo: modify below functions so that they also
* use rope-like metadata *) * use rope-like metadata *)
datatype insert_result = INSERT_UPDATE of t | INSERT_SPLIT of t * t datatype insert_result =
INSERT_UPDATE of t
| INSERT_SPLIT of t * t
fun getMaxSize tree = fun getMaxSize tree =
case tree of case tree of
@@ -394,7 +388,7 @@ struct
val rightNodeSlice = val rightNodeSlice =
VectorSlice.slice (nodes, halfSize, rightLen) VectorSlice.slice (nodes, halfSize, rightLen)
val leftSizeSlice = VectorSlice.slice(sizes, 0, leftLen) val leftSizeSlice = VectorSlice.slice (sizes, 0, leftLen)
val rightSizeSlice = val rightSizeSlice =
VectorSlice.slice (sizes, halfSize, rightLen) VectorSlice.slice (sizes, halfSize, rightLen)
@@ -444,24 +438,29 @@ struct
(* have to split this node too *) (* have to split this node too *)
let let
(* slice sizes *) (* slice sizes *)
val leftSize = VectorSlice.full #[getMaxSize left] val leftSize =
val rightSize = VectorSlice.full #[getMaxSize right] VectorSlice.full #[getMaxSize left]
val rightSize =
VectorSlice.full #[getMaxSize right]
val leftLen = SOME idx val leftLen = SOME idx
val rightLen = SOME (Vector.length nodes - idx - 1) val rightLen = SOME (Vector.length nodes - idx - 1)
val leftSizeSlice = VectorSlice.slice (sizes, 0, leftLen) val leftSizeSlice = VectorSlice.slice (sizes, 0, leftLen)
val rightSizeSlice = VectorSlice.slice (sizes, idx + 1, rightLen) val rightSizeSlice =
VectorSlice.slice (sizes, idx + 1, rightLen)
val leftSizes = VectorSlice.concat [leftSizeSlice, leftSize] val leftSizes = VectorSlice.concat [leftSizeSlice, leftSize]
val rightSizes = VectorSlice.concat [rightSizeSlice, rightSize] val rightSizes =
VectorSlice.concat [rightSizeSlice, rightSize]
(* slice nodes *) (* slice nodes *)
val left = VectorSlice.full #[left] val left = VectorSlice.full #[left]
val right = VectorSlice.full #[right] val right = VectorSlice.full #[right]
val leftNodesSlice = VectorSlice.slice (nodes, 0, leftLen) val leftNodesSlice = VectorSlice.slice (nodes, 0, leftLen)
val rightNodesSlice = VectorSlice.slice (nodes, idx + 1, rightLen) val rightNodesSlice =
VectorSlice.slice (nodes, idx + 1, rightLen)
val leftNodes = VectorSlice.concat [leftNodesSlice, left] val leftNodes = VectorSlice.concat [leftNodesSlice, left]
val rightNodes = VectorSlice.concat [right, rightNodesSlice] val rightNodes = VectorSlice.concat [right, rightNodesSlice]
@@ -475,7 +474,8 @@ struct
else else
(* can join children into parent *) (* can join children into parent *)
let let
val midSizes = #[getMaxSize left, getMaxSize right] val midSizes =
#[getMaxSize left, getMaxSize right]
val midSizes = VectorSlice.full midSizes val midSizes = VectorSlice.full midSizes
val midNodes = #[left, right] val midNodes = #[left, right]
val midNodes = VectorSlice.full midNodes val midNodes = VectorSlice.full midNodes
@@ -489,7 +489,7 @@ struct
val leftNodes = VectorSlice.slice (nodes, 0, leftLen) val leftNodes = VectorSlice.slice (nodes, 0, leftLen)
val rightNodes = VectorSlice.slice (nodes, idx, rightLen) val rightNodes = VectorSlice.slice (nodes, idx, rightLen)
val sizes = val sizes =
VectorSlice.concat [leftSizes, midSizes, rightSizes] VectorSlice.concat [leftSizes, midSizes, rightSizes]
val nodes = val nodes =
VectorSlice.concat [leftNodes, midNodes, rightNodes] VectorSlice.concat [leftNodes, midNodes, rightNodes]
@@ -506,80 +506,81 @@ struct
in in
INSERT_UPDATE (LEAF (item, size)) INSERT_UPDATE (LEAF (item, size))
end end
else else if finish > Vector.sub (sizes, Vector.length sizes - 1) then
if finish > Vector.sub (sizes, Vector.length sizes - 1) then if Vector.length sizes = maxSize then
if Vector.length sizes = maxSize then (* have to split *)
(* have to split *) let
let val startLen = SOME halfSize
val startLen = SOME halfSize val midLen = SOME (Vector.length items - halfSize)
val midLen = SOME (Vector.length items - halfSize)
val leftSizes = VectorSlice.slice (sizes, 0, startLen) val leftSizes = VectorSlice.slice (sizes, 0, startLen)
val leftItems = VectorSlice.slice (items, 0, startLen) val leftItems = VectorSlice.slice (items, 0, startLen)
val midSizes = VectorSlice.slice (sizes, halfSize, midLen) val midSizes = VectorSlice.slice (sizes, halfSize, midLen)
val midItems = VectorSlice.slice (items, halfSize, midLen) val midItems = VectorSlice.slice (items, halfSize, midLen)
val rightSizes = VectorSlice.full #[finish] val rightSizes = VectorSlice.full #[finish]
val rightItems = VectorSlice.full #[{start = start, finish = finish}] val rightItems =
VectorSlice.full #[{start = start, finish = finish}]
val rightItems = VectorSlice.concat [midItems, rightItems] val rightItems = VectorSlice.concat [midItems, rightItems]
val leftItems = VectorSlice.vector leftItems val leftItems = VectorSlice.vector leftItems
val rightSizes = VectorSlice.concat [midSizes, rightSizes] val rightSizes = VectorSlice.concat [midSizes, rightSizes]
val leftSizes = VectorSlice.vector leftSizes val leftSizes = VectorSlice.vector leftSizes
val left = LEAF (leftItems, leftSizes) val left = LEAF (leftItems, leftSizes)
val right = LEAF (rightItems, rightSizes) val right = LEAF (rightItems, rightSizes)
in in
INSERT_SPLIT (left, right) INSERT_SPLIT (left, right)
end end
else else
(* can just append *) (* can just append *)
let let
val sizes = Vector.concat [sizes, #[finish]] val sizes = Vector.concat [sizes, #[finish]]
val item = #[{start = start, finish = finish}] val item = #[{start = start, finish = finish}]
val items = Vector.concat [items, item] val items = Vector.concat [items, item]
in in
INSERT_UPDATE (LEAF (items, sizes)) INSERT_UPDATE (LEAF (items, sizes))
end end
else if finish < #start (Vector.sub (items, 0)) then else if finish < #start (Vector.sub (items, 0)) then
(* prepend *) (* prepend *)
if Vector.length sizes = maxSize then if Vector.length sizes = maxSize then
(* have to split *) (* have to split *)
let let
val leftSizes = VectorSlice.full #[finish] val leftSizes = VectorSlice.full #[finish]
val leftItems = VectorSlice.full #[{start = start, finish = finish}] val leftItems =
VectorSlice.full #[{start = start, finish = finish}]
val midLen = SOME halfSize val midLen = SOME halfSize
val rightLen = SOME (Vector.length items - halfSize) val rightLen = SOME (Vector.length items - halfSize)
val midSizes = VectorSlice.slice (sizes, 0, midLen) val midSizes = VectorSlice.slice (sizes, 0, midLen)
val midItems = VectorSlice.slice (items, 0, midLen) val midItems = VectorSlice.slice (items, 0, midLen)
val rightSizes = VectorSlice.slice (sizes, halfSize, rightLen) val rightSizes = VectorSlice.slice (sizes, halfSize, rightLen)
val rightItems = VectorSlice.slice (items, halfSize, rightLen) val rightItems = VectorSlice.slice (items, halfSize, rightLen)
val leftSizes = VectorSlice.concat [leftSizes, midSizes] val leftSizes = VectorSlice.concat [leftSizes, midSizes]
val rightSizes = VectorSlice.vector rightSizes val rightSizes = VectorSlice.vector rightSizes
val leftItems = VectorSlice.concat [leftItems, midItems] val leftItems = VectorSlice.concat [leftItems, midItems]
val rightItems = VectorSlice.vector rightItems val rightItems = VectorSlice.vector rightItems
val left = LEAF (leftItems, leftSizes) val left = LEAF (leftItems, leftSizes)
val right = LEAF (rightItems, rightSizes) val right = LEAF (rightItems, rightSizes)
in in
INSERT_SPLIT (left, right) INSERT_SPLIT (left, right)
end end
else else
(* just prepend *) (* just prepend *)
let let
val sizes = Vector.concat [#[finish], sizes] val sizes = Vector.concat [#[finish], sizes]
val item = {start = start, finish = finish} val item = {start = start, finish = finish}
val items = Vector.concat [#[item], items] val items = Vector.concat [#[item], items]
in in
INSERT_UPDATE (LEAF (items, sizes)) INSERT_UPDATE (LEAF (items, sizes))
end end
else else
(* insert into middle *) (* insert into middle *)
let let
@@ -593,7 +594,8 @@ struct
val leftItems = VectorSlice.slice (items, 0, leftLen) val leftItems = VectorSlice.slice (items, 0, leftLen)
val rightItems = VectorSlice.slice (items, idx, rightLen) val rightItems = VectorSlice.slice (items, idx, rightLen)
val midSize = VectorSlice.full #[finish] val midSize = VectorSlice.full #[finish]
val midItem = VectorSlice.full #[{start = start, finish = finish}] val midItem =
VectorSlice.full #[{start = start, finish = finish}]
in in
if Vector.length items = maxSize then if Vector.length items = maxSize then
(* have to return split *) (* have to return split *)
@@ -619,14 +621,14 @@ struct
end end
end end
fun insert (start, finish, tree) = fun insert (start, finish, tree) =
case helpInsert (start, finish, tree) of case helpInsert (start, finish, tree) of
INSERT_UPDATE tree => tree INSERT_UPDATE tree => tree
| INSERT_SPLIT (left, right) => | INSERT_SPLIT (left, right) =>
let let
val sizes = #[getMaxSize left, getMaxSize right] val sizes = #[getMaxSize left, getMaxSize right]
val nodes = #[left, right] val nodes = #[left, right]
in in
BRANCH (nodes, sizes) BRANCH (nodes, sizes)
end end
end end