mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-11-29 04:04:02 +03:00
1558 lines
36 KiB
Plaintext
1558 lines
36 KiB
Plaintext
:> basic containers
|
|
|%
|
|
::
|
|
++ first
|
|
|* a=^
|
|
-.a
|
|
::
|
|
++ second
|
|
|* a=^
|
|
+.a
|
|
::
|
|
++ either |*([a=mold b=mold] $%({$& p/a} {$| p/b})) :: either
|
|
::
|
|
++ thr
|
|
|%
|
|
++ apply
|
|
:> applies {b} {a} is first, or {b} to {a} is second.
|
|
|* [a=(either) b=$-(* *) c=$-(* *)]
|
|
?- -.a
|
|
$& (b p.a)
|
|
$| (c p.a)
|
|
==
|
|
::
|
|
++ firsts
|
|
:> returns a list of all first elements in {a}.
|
|
|* a=(list (either))
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
~
|
|
?- -.i.a
|
|
$& [p.i.a $(a t.a)]
|
|
$| $(a t.a)
|
|
==
|
|
::
|
|
++ seconds
|
|
:> returns a list of all second elements in {a}.
|
|
|* a=(list (either))
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
~
|
|
?- -.i.a
|
|
$& $(a t.a)
|
|
$| [p.i.a $(a t.a)]
|
|
==
|
|
::
|
|
++ partition
|
|
:> splits the list of eithers into two lists based on first or second.
|
|
|* a=(list (either))
|
|
=> .(a (homo a))
|
|
|-
|
|
^- {(list _?>(?=({{%& *} *} a) p.i.a)) (list _?>(?=({{%| *} *} a) p.i.a))}
|
|
?~ a
|
|
[~ ~]
|
|
=+ ret=$(a t.a)
|
|
?- -.i.a
|
|
$& [[p.i.a -.ret] +.ret]
|
|
$| [-.ret [p.i.a +.ret]]
|
|
==
|
|
--
|
|
++ maybe |*(a=mold $@($~ {$~ u/a})) :: maybe
|
|
++ myb
|
|
|%
|
|
++ is-null
|
|
:> returns %.y if maybe is null.
|
|
:>
|
|
:> corresponds to {isJust} in haskell.
|
|
|* a=(maybe)
|
|
:> whether {a} is null.
|
|
?~ a %.y
|
|
%.n
|
|
::
|
|
++ exists
|
|
:> returns %.y if maybe contains a real value.
|
|
:>
|
|
:> corresponds to {isNothing} in haskell.
|
|
|* a=(maybe)
|
|
:> whether {a} is not null.
|
|
?~ a %.n
|
|
%.y
|
|
::
|
|
++ need
|
|
:> returns the value or crashes.
|
|
:>
|
|
:> corresponds to {fromJust} in haskell.
|
|
|* a=(maybe)
|
|
?~ a ~>(%mean.[%leaf "need"] !!)
|
|
:> the value from the maybe.
|
|
u.a
|
|
::
|
|
++ default
|
|
:> returns the value in the maybe, or a default value on null.
|
|
:>
|
|
:> corresponds to {fromMaybe} in haskell.
|
|
|* [a=(maybe) b=*]
|
|
?~(a b u.a)
|
|
::
|
|
++ from-list
|
|
:> returns the first value of the list, or null on empty list.
|
|
:>
|
|
:> corresponds to {listToMaybe} in haskell.
|
|
|* a=(list)
|
|
^- (maybe _i.a)
|
|
?~ a ~
|
|
[~ i.a]
|
|
::
|
|
++ to-list
|
|
:> converts the maybe to a list.
|
|
:>
|
|
:> corresponds to {maybeToList} in haskell.
|
|
|* a=(maybe)
|
|
^- (list _u.a)
|
|
?~ a ~
|
|
[u.a ~]
|
|
::
|
|
++ concat
|
|
:> converts a list of maybes to a list of non-null values.
|
|
:>
|
|
:> corresponds to {catMaybes} in haskell.
|
|
|* a=(list (maybe))
|
|
=> .(a (homo a))
|
|
|-
|
|
^- (list _u.+.i.-.a)
|
|
?~ a ~
|
|
?~ i.a
|
|
$(a t.a)
|
|
[u.i.a $(a t.a)]
|
|
::
|
|
++ map
|
|
:> a version of map that can throw out items.
|
|
:>
|
|
:> takes a list of items and a function of the type
|
|
:>
|
|
:> todo: while this was in Data.Maybe in haskell, this might better
|
|
:> logically be put in our list class? murn is.
|
|
:>
|
|
:> corresponds to {mapMaybes} in haskell.
|
|
|* [a=(list) b=$-(* (maybe))]
|
|
=> .(a (homo a))
|
|
|-
|
|
^- (list _,.+:*b)
|
|
?~ a ~
|
|
=+ c=(b i.a)
|
|
?~ c
|
|
$(a t.a)
|
|
:: todo: the span of c does not have the faces of a maybe. how do i either
|
|
:: force a resurface or act safely on the incoming?
|
|
[+.c $(a t.a)]
|
|
::
|
|
++ apply
|
|
:> applies {b} to {a}.
|
|
|* [a=(maybe) b=$-(* (maybe))]
|
|
?~ a ~
|
|
(b u.a)
|
|
::
|
|
:: todo: bind, bond, both, flit, hunt, lift, mate,
|
|
::
|
|
:: used in other files: bond, drop (but only once)
|
|
:: unusued: clap
|
|
--
|
|
++ ls
|
|
:: we are back to a basic problem here: when we try to pass lists without
|
|
:: {i} and {t} faces, we have to use {-} and {+} to access the structure of
|
|
:: the list. but we then can't deal with incoming lists that do have faces,
|
|
:: as `+:[i="one" t=~]` is `t=~`, not `~`.
|
|
::
|
|
:: what i really want is that the sapn outside a |* is `{"" 2 "" $~}`, but
|
|
:: inside, it is `(list $?(@ud tape))`. all of a sudden, you don't need
|
|
:: ++limo or ++homo, because you have the right span from the beginning!
|
|
:: those two functions really feel like they're working around the type
|
|
:: system instead of cooperating with it.
|
|
::
|
|
:> list utilities
|
|
|%
|
|
:> # %basic
|
|
:> basic list manipulation
|
|
+|
|
|
::
|
|
++ head
|
|
:> returns the first item in the list, which must be non-empty.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
:> the first item in the list.
|
|
?~ a ~>(%mean.[%leaf "head"] !!)
|
|
i.a
|
|
::
|
|
++ last
|
|
:> returns the final item in the list, which must be non-empty.
|
|
|* a=(list)
|
|
:> the last item in a list.
|
|
?~ a ~>(%mean.[%leaf "last"] !!)
|
|
?~ t.a
|
|
i.a
|
|
$(a t.a)
|
|
::
|
|
++ tail
|
|
:> returns all items after the head of the list, which must be non-empty.
|
|
|* a=(list)
|
|
^+ a
|
|
?~ a ~>(%mean.[%leaf "tail"] !!)
|
|
t.a
|
|
::
|
|
++ init
|
|
:> returns all items in the list except the last one. must be non-empty.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ a
|
|
?~ a ~>(%mean.[%leaf "init"] !!)
|
|
|-
|
|
?~ t.a
|
|
~
|
|
[i.a $(a t.a)]
|
|
:: ::
|
|
:: :: ommitted: uncons, null
|
|
:: ::
|
|
++ size
|
|
:> returns the number of items in {a}.
|
|
:>
|
|
:> corresponds to {length} in haskell.
|
|
|= a=(list)
|
|
=| b=@u
|
|
^- @u
|
|
|-
|
|
?~ a
|
|
b
|
|
$(a t.a, b +(b))
|
|
::
|
|
:> # %transformations
|
|
:> functions which change a list into another list
|
|
+|
|
|
::
|
|
++ map
|
|
:> applies a gate to each item in the list.
|
|
|* [a=(list) b=$-(* *)]
|
|
^- (list _*b)
|
|
?~ a ~
|
|
[(b i.a) $(a t.a)]
|
|
::
|
|
++ reverse
|
|
:> reverses the order of the items in the list.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
^+ a
|
|
=+ b=`_a`~
|
|
|-
|
|
?~ a b
|
|
$(a t.a, b [i.a b])
|
|
::
|
|
++ intersperse
|
|
:> places {a} between each element in {b}.
|
|
|* [a=* b=(list)]
|
|
=> .(b (homo b))
|
|
|-
|
|
^+ (homo [a b])
|
|
?~ b
|
|
~
|
|
=+ c=$(b t.b)
|
|
?~ c
|
|
[i.b ~]
|
|
[i.b a c]
|
|
::
|
|
++ intercalate
|
|
:> places {a} between each list in {b}, and flatten to a single list.
|
|
|* [a=(list) b=(list (list))]
|
|
=> .(a ^.(homo a), b ^.(homo b))
|
|
|-
|
|
^+ (concat [a b])
|
|
?~ b
|
|
~
|
|
=+ c=$(b t.b)
|
|
?~ c
|
|
i.b
|
|
:(weld i.b a c)
|
|
::
|
|
++ transpose
|
|
:> transposes rows and columns of a 2d list structure.
|
|
|* input=(list (list))
|
|
:: todo: this should homogenize with each sublist.
|
|
^- (list (list))
|
|
=/ items
|
|
%^ foldl input `{(list) (list (list))}`[~ ~]
|
|
|= :> current: the list of first items under construction.
|
|
:> remaining: the remaining item lists.
|
|
:> next: the next list in {input}.
|
|
{state/{current/(list) remaining/(list (list))} next/(list)}
|
|
?~ next
|
|
state
|
|
?~ t.next
|
|
[[i.next current.state] remaining.state]
|
|
[[i.next current.state] [t.next remaining.state]]
|
|
?~ +.items
|
|
`(list (list))`[(reverse -.items) ~]
|
|
[(reverse -.items) $(input (reverse +.items))]
|
|
::
|
|
:: :: ++ subsequences
|
|
:: :: |= a=(list)
|
|
:: :: ?~ a
|
|
:: :: ~
|
|
:: :: :- -.a
|
|
:: :: %^ foldr
|
|
:: :: $(a +.a)
|
|
:: :: `(list)`~
|
|
:: :: |= [ys=(list) r=(list)]
|
|
:: :: ~ ::[ys [-.a ys] r ~]
|
|
:: :: TODO:
|
|
:: :: ++subsequences
|
|
:: :: ++permutations
|
|
|
|
::
|
|
:> # %folds
|
|
:> functions which reduce a list to a value
|
|
+|
|
|
::
|
|
++ foldl
|
|
:> left associative fold
|
|
:>
|
|
:> this follows haskell giving an explicit starting value instead of {roll}.
|
|
|* [a=(list) b=* c=$-({* *} *)]
|
|
^+ b
|
|
?~ a
|
|
b
|
|
$(a t.a, b (c b i.a))
|
|
::
|
|
++ foldr
|
|
:> right associative fold
|
|
|* [a=(list) b=* c=$-({* *} *)]
|
|
^+ b
|
|
?~ a
|
|
b
|
|
(c $(a t.a) i.a)
|
|
::
|
|
++ concat
|
|
:> concatenate a list of lists into a single level.
|
|
|* a=(list (list))
|
|
=> .(a ^.(homo a))
|
|
|- ^+ (homo i:-.a)
|
|
?~ a
|
|
~
|
|
(weld (homo i.a) $(a t.a))
|
|
::
|
|
++ weld
|
|
:> combine two lists, possibly of different types.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a ^.(homo a), b ^.(homo b))
|
|
|- ^- (list $?(_i.-.a _i.-.b))
|
|
?~ a b
|
|
[i.a $(a t.a)]
|
|
::
|
|
++ any
|
|
:> returns yes if any element satisfies the predicate
|
|
|* [a=(list) b=$-(* ?)]
|
|
?~ a
|
|
%.n
|
|
?|((b i.a) $(a t.a))
|
|
::
|
|
++ all
|
|
:> returns yes if all elements satisfy the predicate
|
|
|* [a=(list) b=$-(* ?)]
|
|
?~ a
|
|
%.y
|
|
?&((b i.a) $(a t.a))
|
|
::
|
|
:: haskell has a bunch of methods like sum or maximum which leverage type
|
|
:: classes, but I don't think they can be written generically in hoon.
|
|
::
|
|
::
|
|
:> # %building
|
|
:> functions which build lists
|
|
+|
|
|
++ scanl
|
|
:> returns a list of successive reduced values from the left.
|
|
|* [a=(list) b=* c=$-({* *} *)]
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
[b ~]
|
|
[b $(a t.a, b (c b i.a))]
|
|
::
|
|
++ scanl1
|
|
:> a variant of ++scanl that has no starting value.
|
|
|* [a=(list) c=$-({* *} *)]
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
~
|
|
?~ t.a
|
|
~
|
|
(scanl t.a i.a c)
|
|
::
|
|
++ scanr
|
|
:> the right-to-left version of scanl.
|
|
|* [a=(list) b=* c=$-({* *} *)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^- (list _b)
|
|
?~ a
|
|
[b ~]
|
|
=+ rest=$(a t.a)
|
|
?> ?=(^ rest)
|
|
[(c i.a i.rest) rest]
|
|
::
|
|
++ scanr1
|
|
:> a variant of ++scanr that has no starting value.
|
|
|* [a=(list) c=$-({* *} *)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ a
|
|
?~ a
|
|
~
|
|
?~ t.a
|
|
[i.a ~]
|
|
=+ rest=$(a t.a)
|
|
?> ?=(^ rest)
|
|
[(c i.a i.rest) rest]
|
|
::
|
|
++ map-foldl
|
|
:> performs both a ++map and a ++foldl in one pass.
|
|
:>
|
|
:> corresponds to {mapAccumL} in haskell.
|
|
|* [a=(list) b=* c=$-({* *} {* *})]
|
|
^- {_b (list _+:*c)}
|
|
?~ a
|
|
[b ~]
|
|
=+ d=(c b i.a)
|
|
=+ recurse=$(a t.a, b -.d)
|
|
[-.recurse [+.d +.recurse]]
|
|
::
|
|
++ map-foldr
|
|
:> performs both a ++map and a ++foldr in one pass.
|
|
:>
|
|
:> corresponds to {mapAccumR} in haskell.
|
|
|* [a=(list) b=* c=$-({* *} {* *})]
|
|
^- {_b (list _+:*c)}
|
|
?~ a
|
|
[b ~]
|
|
=+ recurse=$(a t.a)
|
|
=+ d=(c -.recurse i.a)
|
|
[-.d [+.d +.recurse]]
|
|
::
|
|
++ unfoldr
|
|
:> generates a list from a seed value and a function.
|
|
|* [b=* c=$-(* (maybe {* *}))]
|
|
|-
|
|
^- (list _b)
|
|
=+ current=(c b)
|
|
?~ current
|
|
~
|
|
:: todo: the span of {c} is resurfaced to have a u. this might do funky
|
|
:: things with faces.
|
|
[-.+.current $(b +.+.current)]
|
|
::
|
|
:> # %sublists
|
|
:> functions which return a portion of the list
|
|
+|
|
|
::
|
|
++ take
|
|
:> returns the first {a} elements of {b}.
|
|
|* [a=@ b=(list)]
|
|
=> .(b (homo b))
|
|
|-
|
|
^+ b
|
|
?: =(0 a)
|
|
~
|
|
?~ b
|
|
~
|
|
[i.b $(a (dec a), b +.b)]
|
|
::
|
|
++ drop
|
|
:> returns {b} without the first {a} elements.
|
|
|* [a=@ b=(list)]
|
|
?: =(0 a)
|
|
b
|
|
?~ b
|
|
b
|
|
$(a (dec a), b +.b)
|
|
::
|
|
++ split-at
|
|
:> returns {b} split into two lists at the {a}th element.
|
|
|* [a=@ b=(list)]
|
|
=> .(b (homo b))
|
|
|-
|
|
^+ [b b]
|
|
?: =(0 a)
|
|
[~ b]
|
|
?~ b
|
|
[~ b]
|
|
=+ d=$(a (dec a), b t.b)
|
|
[[i.b -.d] +.d]
|
|
::
|
|
++ take-while
|
|
:> returns elements from {a} until {b} returns %.no.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ a
|
|
?~ a
|
|
~
|
|
?. (b -.a)
|
|
~
|
|
[i.a $(a t.a)]
|
|
::
|
|
++ drop-while
|
|
:> returns elements form {a} once {b} returns %.no.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
~
|
|
?. (b i.a)
|
|
a
|
|
$(a t.a)
|
|
::
|
|
++ drop-while-end
|
|
:> drops the largest suffix of {a} which matches {b}.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a
|
|
~
|
|
=+ r=$(a t.a)
|
|
?: ?&(=(r ~) (b i.a))
|
|
~
|
|
[i.a r]
|
|
::
|
|
++ split-on
|
|
:> returns [the longest prefix of {b}, the rest of the list].
|
|
:>
|
|
:> corresponds to {span} in haskell. renamed to not conflict with hoon.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ [a a]
|
|
?~ a
|
|
[~ ~]
|
|
?. (b i.a)
|
|
[~ a]
|
|
=+ d=$(a +.a)
|
|
[[i.a -.d] +.d]
|
|
::
|
|
++ break
|
|
:> like {split-on}, but reverses the return code of {b}.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ [a a]
|
|
?~ a
|
|
[~ ~]
|
|
?: (b i.a)
|
|
[~ a]
|
|
=+ d=$(a t.a)
|
|
[[i.a -.d] +.d]
|
|
::
|
|
++ strip-prefix
|
|
:> returns a {maybe} of {b} with the prefix {a} removed, or ~ if no match.
|
|
|* [a=(list) b=(list)]
|
|
^- (maybe _b)
|
|
?~ a
|
|
`b
|
|
?~ b
|
|
~
|
|
$(a +.a, b +.b)
|
|
::
|
|
:: todo: ++group
|
|
::
|
|
++ inits
|
|
:> returns all initial segments in reverse order.
|
|
:>
|
|
:> unlike haskell, this does not return the empty list as the first
|
|
:> element, as hoon uses null as the list terminator.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
%- flop
|
|
|-
|
|
?~ a ~
|
|
[a $(a (init a))]
|
|
::
|
|
++ tails
|
|
:> returns all final segments, longest first.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
|-
|
|
?~ a ~
|
|
[a $(a t.a)]
|
|
::
|
|
:> # %predicates
|
|
:> functions which compare lists
|
|
+|
|
|
::
|
|
++ is-prefix-of
|
|
:> returns %.y if the first list is a prefix of the second.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
|-
|
|
^- ?
|
|
?~ a
|
|
%.y
|
|
?~ b
|
|
%.n
|
|
?. =(i.a i.b)
|
|
%.n
|
|
$(a t.a, b t.b)
|
|
::
|
|
++ is-suffix-of
|
|
:> returns %.y if the first list is the suffix of the second.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
^- ?
|
|
:: todo: this is performant in haskell because of laziness but may not be
|
|
:: adequate in hoon.
|
|
(is-prefix-of (reverse a) (reverse b))
|
|
::
|
|
++ is-infix-of
|
|
:> returns %.y if the first list appears anywhere in the second.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
|-
|
|
^- ?
|
|
?~ a
|
|
%.y
|
|
?~ b
|
|
%.n
|
|
?: (is-prefix-of a b)
|
|
%.y
|
|
$(b t.b)
|
|
::
|
|
:: todo: ++is-subsequence-of
|
|
::
|
|
:> # %searching
|
|
:> finding items in lists
|
|
::
|
|
++ elem
|
|
:> does {a} occur in list {b}?
|
|
|* [a=* b=(list)]
|
|
?~ b
|
|
%.n
|
|
?: =(a i.b)
|
|
%.y
|
|
$(b t.b)
|
|
::
|
|
++ lookup
|
|
:> looks up the key {a} in the association list {b}
|
|
|* [a=* b=(list (pair))]
|
|
^- (maybe _+.-.b)
|
|
?~ b
|
|
~
|
|
?: =(a p.i.b)
|
|
[~ q.i.b]
|
|
$(b t.b)
|
|
::
|
|
++ find
|
|
:> returns the first element of {a} which matches predicate {b}.
|
|
|* [a=(list) b=$-(* ?)]
|
|
^- (maybe _-.a)
|
|
?~ a
|
|
~
|
|
?: (b i.a)
|
|
[~ i.a]
|
|
$(a t.a)
|
|
::
|
|
++ filter
|
|
:> filter all items in {a} which match predicate {b}.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ a
|
|
?~ a
|
|
~
|
|
?. (b i.a)
|
|
[i.a $(a t.a)]
|
|
$(a t.a)
|
|
::
|
|
++ partition
|
|
:> returns two lists, one whose elements match {b}, the other which doesn't.
|
|
|* [a=(list) b=$-(* ?)]
|
|
=> .(a (homo a))
|
|
|-
|
|
^+ [a a]
|
|
?~ a
|
|
[~ ~]
|
|
=+ rest=$(a t.a)
|
|
?: (b i.a)
|
|
[[i.a -.rest] +.rest]
|
|
[-.rest [i.a +.rest]]
|
|
::
|
|
:> # %indexing
|
|
:> finding indices in lists
|
|
+|
|
|
::
|
|
++ elem-index
|
|
:> returns {maybe} the first occurrence of {a} occur in list {b}.
|
|
=| i=@u
|
|
|= [a=* b=(list)]
|
|
^- (maybe @ud)
|
|
?~ b
|
|
~
|
|
?: =(a i.b)
|
|
`i
|
|
$(b t.b, i +(i))
|
|
::
|
|
++ elem-indices
|
|
:> returns a list of indices of all occurrences of {a} in {b}.
|
|
=| i/@u
|
|
|= [a=* b=(list)]
|
|
^- (list @ud)
|
|
?~ b
|
|
~
|
|
?: =(a i.b)
|
|
[i $(b t.b, i +(i))]
|
|
$(b t.b, i +(i))
|
|
::
|
|
++ find-index
|
|
:> returns {maybe} the first occurrence which matches {b} in {a}.
|
|
=| i=@u
|
|
|* [a=(list) b=$-(* ?)]
|
|
^- (maybe @ud)
|
|
?~ a
|
|
~
|
|
?: (b i.a)
|
|
`i
|
|
$(a t.a, i +(i))
|
|
::
|
|
++ find-indices
|
|
:> returns a list of indices of all items in {a} which match {b}.
|
|
=| i=@u
|
|
|* [a=(list) b=$-(* ?)]
|
|
^- (list @ud)
|
|
?~ a
|
|
~
|
|
?: (b i.a)
|
|
[i $(a t.a, i +(i))]
|
|
$(a t.a, i +(i))
|
|
::
|
|
++ zip
|
|
:> takes a list of lists, returning a list of each first items.
|
|
|* a=(list (list))
|
|
=> .(a (multi-homo a))
|
|
|^ ^+ a
|
|
?~ a ~
|
|
?. valid
|
|
~
|
|
=+ h=heads
|
|
?~ h ~
|
|
[heads $(a tails)]
|
|
::
|
|
++ valid
|
|
%+ all a
|
|
|= next=(list)
|
|
?~ a %.n
|
|
%.y
|
|
::
|
|
++ heads
|
|
^+ (homo i:-.a)
|
|
|-
|
|
?~ a ~
|
|
?~ i.a ~
|
|
[i.i.a $(a t.a)]
|
|
::
|
|
++ tails
|
|
^+ a
|
|
|-
|
|
?~ a ~
|
|
?~ i.a ~
|
|
[t.i.a $(a t.a)]
|
|
--
|
|
++ multi-homo
|
|
|* a=(list (list))
|
|
^+ =< $
|
|
|% +- $ ?:(*? ~ [i=(homo (snag 0 a)) t=$])
|
|
--
|
|
a
|
|
::
|
|
:> # %set
|
|
:> set operations on lists
|
|
+|
|
|
++ unique
|
|
:> removes duplicates elements from {a}
|
|
:>
|
|
:> corresponds to {nub} in haskell.
|
|
|* a=(list)
|
|
=> .(a (homo a))
|
|
=| seen/(list)
|
|
^+ a
|
|
|-
|
|
?~ a
|
|
~
|
|
?: (elem i.a seen)
|
|
$(a t.a)
|
|
[i.a $(seen [i.a seen], a t.a)]
|
|
::
|
|
++ delete
|
|
:> removes the first occurrence of {a} in {b}
|
|
|* [a=* b=(list)]
|
|
=> .(b (homo b))
|
|
^+ b
|
|
|-
|
|
?~ b
|
|
~
|
|
?: =(a i.b)
|
|
t.b
|
|
[i.b $(b t.b)]
|
|
::
|
|
++ delete-firsts
|
|
:> deletes the first occurrence of each element in {b} from {a}.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
|-
|
|
^+ a
|
|
?~ a
|
|
~
|
|
?~ b
|
|
a
|
|
?: (elem i.a b)
|
|
$(a t.a, b (delete i.a b))
|
|
[i.a $(a t.a)]
|
|
::
|
|
++ union
|
|
:> the list union of {a} and {b}.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
|-
|
|
^+ (weld a b)
|
|
?~ a
|
|
b
|
|
?~ b
|
|
~
|
|
[i.a $(a t.a, b (delete i.a b))]
|
|
::
|
|
++ intersect
|
|
:> the intersection of {a} and {b}.
|
|
|* [a=(list) b=(list)]
|
|
=> .(a (homo a), b (homo b))
|
|
|-
|
|
^+ a
|
|
?~ a
|
|
~
|
|
?: (elem i.a b)
|
|
[i.a $(a t.a)]
|
|
$(a t.a)
|
|
::
|
|
:: todo: everything about ++sort and ++sort-on needs more thought. the
|
|
:: haskell implementation uses the Ord typeclass to sort things by
|
|
:: default. ++sort as is is probably the correct thing to do.
|
|
::
|
|
--
|
|
::
|
|
++ dict
|
|
:> a dictionary mapping keys of {a} to values of {b}.
|
|
:>
|
|
:> a dictionary is treap ordered; it builds a treap out of the hashed key
|
|
:> values.
|
|
|* [a=mold b=mold]
|
|
%+ cork (tree (pair a b))
|
|
|= c/(tree (pair a b)) ^+ c
|
|
?.((valid:dct c) ~ c)
|
|
::
|
|
++ dct
|
|
|%
|
|
:> # %query
|
|
:> looks up values in the dict.
|
|
+|
|
|
++ empty
|
|
:> is the dict empty?
|
|
|* a=(dict)
|
|
?~ a %.y
|
|
%.n
|
|
::
|
|
++ size
|
|
:> returns the number of elements in {a}.
|
|
|= a=(dict)
|
|
^- @u
|
|
?~ a 0
|
|
:(add 1 $(a l.a) $(a r.a))
|
|
::
|
|
++ member
|
|
:> returns %.y if {b} is a key in {a}.
|
|
|= [a=(dict) key=*]
|
|
^- ?
|
|
?~ a %.n
|
|
?|(=(key p.n.a) $(a l.a) $(a r.a))
|
|
::
|
|
++ get
|
|
:> grab value by key.
|
|
|* [a=(dict) key=*]
|
|
^- (maybe _?>(?=(^ a) q.n.a))
|
|
:: ^- {$@($~ {$~ u/_?>(?=(^ a) q.n.a)})}
|
|
?~ a
|
|
~
|
|
?: =(key p.n.a)
|
|
`q.n.a
|
|
?: (gor key p.n.a)
|
|
$(a l.a)
|
|
$(a r.a)
|
|
::
|
|
:: :: todo: is ++got the correct interface to have? Haskell has lookup which
|
|
:: :: returns a Maybe and a findWithDefault which passes in a default value.
|
|
:: ++ got
|
|
:: :> todo: move impl here.
|
|
:: :> todo: is there a way to make b/_<><>.a ?
|
|
:: |* [a=(dict) key=*]
|
|
:: (~(got by a) key)
|
|
::
|
|
:: todo: skipping several methods which rely on the the Ord typeclass, like
|
|
:: lookupLT.
|
|
::
|
|
:> # %insertion
|
|
+|
|
|
++ put
|
|
:> inserts a new key/value pair, replacing the current value if it exists.
|
|
:>
|
|
:> corresponds to {insert} in haskell.
|
|
|* [a=(dict) key=* value=*]
|
|
|- ^+ a
|
|
?~ a
|
|
[[key value] ~ ~]
|
|
?: =(key p.n.a)
|
|
?: =(value q.n.a)
|
|
a
|
|
[[key value] l.a r.a]
|
|
?: (gor key p.n.a)
|
|
=+ d=$(a l.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a d r.a]
|
|
[n.d l.d [n.a r.d r.a]]
|
|
=+ d=$(a r.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a l.a d]
|
|
[n.d [n.a l.a l.d] r.d]
|
|
::
|
|
++ put-with
|
|
:> inserts {key}/{value}, applying {fun} if {key} already exists.
|
|
:>
|
|
:> corresponds to {insertWith} in haskell.
|
|
|* [a=(dict) key=* value=* fun=$-({* *} *)]
|
|
|- ^+ a
|
|
?~ a
|
|
[[key value] ~ ~]
|
|
?: =(key p.n.a)
|
|
:: key already exists; use {fun} to resolve.
|
|
[[key (fun q.n.a value)] l.a r.a]
|
|
?: (gor key p.n.a)
|
|
=+ d=$(a l.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a d r.a]
|
|
[n.d l.d [n.a r.d r.a]]
|
|
=+ d=$(a r.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a l.a d]
|
|
[n.d [n.a l.a l.d] r.d]
|
|
::
|
|
++ put-with-key
|
|
:> inserts {key}/{value}, applying {fun} if {key} already exists.
|
|
:>
|
|
:> corresponds to {insertWithKey} in haskell.
|
|
|* [a=(dict) key=* value=* fun=$-({* * *} *)]
|
|
|- ^+ a
|
|
?~ a
|
|
[[key value] ~ ~]
|
|
?: =(key p.n.a)
|
|
:: key already exists; use {fun} to resolve.
|
|
[[key (fun p.n.a q.n.a value)] l.a r.a]
|
|
?: (gor key p.n.a)
|
|
=+ d=$(a l.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a d r.a]
|
|
[n.d l.d [n.a r.d r.a]]
|
|
=+ d=$(a r.a)
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a l.a d]
|
|
[n.d [n.a l.a l.d] r.d]
|
|
::
|
|
++ put-lookup-with-key
|
|
:> combines insertion with lookup in one pass.
|
|
:>
|
|
:> corresponds to {insertLookupWithKey} in haskell.
|
|
|* [a=(dict) key=* value=* fun=$-({* * *} *)]
|
|
|- ^- {(maybe _value) _a}
|
|
?~ a
|
|
[~ [[key value] ~ ~]]
|
|
?: =(key p.n.a)
|
|
:: key already exists; use {fun} to resolve.
|
|
[`q.n.a [[key (fun p.n.a q.n.a value)] l.a r.a]]
|
|
?: (gor key p.n.a)
|
|
=+ rec=$(a l.a)
|
|
=+ d=+.rec
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[-.rec [n.a d r.a]]
|
|
[-.rec [n.d l.d [n.a r.d r.a]]]
|
|
=+ rec=$(a r.a)
|
|
=+ d=+.rec
|
|
?> ?=(^ d)
|
|
?: (vor p.n.a p.n.d)
|
|
[-.rec [n.a l.a d]]
|
|
[-.rec [n.d [n.a l.a l.d] r.d]]
|
|
::
|
|
:> # %delete-update
|
|
+|
|
|
::
|
|
++ delete
|
|
:> deletes entry at {key}.
|
|
|* [a=(dict) key=*]
|
|
|- ^+ a
|
|
?~ a
|
|
~
|
|
?. =(key p.n.a)
|
|
?: (gor key p.n.a)
|
|
[n.a $(a l.a) r.a]
|
|
[n.a l.a $(a r.a)]
|
|
(pop-top a)
|
|
::
|
|
++ adjust
|
|
:> updates a value at {key} by passing the value to {fun}.
|
|
|* [a=(dict) key=* fun=$-(* *)]
|
|
%^ alter-with-key a key
|
|
|= [key=_p.-.n.-.a value=(maybe _q.+.n.-.a)]
|
|
^- (maybe _q.+.n.-.a)
|
|
?~ value ~
|
|
[~ (fun u.value)]
|
|
::
|
|
++ adjust-with-key
|
|
:> updates a value at {key} by passing the key/value pair to {fun}.
|
|
|* [a=(dict) key=* fun=$-({* *} *)]
|
|
%^ alter-with-key a key
|
|
|= [key=_p.-.n.-.a value=(maybe _q.+.n.-.a)]
|
|
^- (maybe _q.+.n.-.a)
|
|
?~ value ~
|
|
[~ (fun key u.value)]
|
|
::
|
|
++ update
|
|
:> adjusts or deletes the value at {key} by {fun}.
|
|
|* [a=(dict) key=* fun=$-(* (maybe *))]
|
|
%^ alter-with-key a key
|
|
|= [key=_p.-.n.-.a value=(maybe _q.+.n.-.a)]
|
|
^- (maybe _q.+.n.-.a)
|
|
?~ value ~
|
|
(fun u.value)
|
|
::
|
|
++ update-with-key
|
|
:> adjusts or deletes the value at {key} by {fun}.
|
|
|* [a=(dict) key=* fun=$-({* *} (maybe *))]
|
|
%^ alter-with-key a key
|
|
|= [key=_p.-.n.-.a value=(maybe _q.+.n.-.a)]
|
|
^- (maybe _q.+.n.-.a)
|
|
?~ value ~
|
|
(fun key u.value)
|
|
::
|
|
:: todo:
|
|
:: ++update-lookup-with-key
|
|
::
|
|
++ alter
|
|
:> inserts, deletes, or updates a value by {fun}.
|
|
|* [a=(dict) key=* fun=$-((maybe *) (maybe *))]
|
|
%^ alter-with-key a key
|
|
|= [key=_p.-.n.-.a value=(maybe _q.+.n.-.a)]
|
|
(fun value)
|
|
::
|
|
++ alter-with-key
|
|
:> inserts, deletes, or updates a value by {fun}.
|
|
|* [a=(dict) key=* fun=$-({* (maybe *)} (maybe *))]
|
|
|- ^+ a
|
|
?~ a
|
|
=+ ret=(fun key ~)
|
|
?~ ret
|
|
~
|
|
[[key u.ret] ~ ~]
|
|
?: =(key p.n.a)
|
|
=+ ret=(fun key `q.n.a)
|
|
?~ ret
|
|
(pop-top a)
|
|
?: =(u.ret q.n.a)
|
|
a
|
|
[[key u.ret] l.a r.a]
|
|
?: (gor key p.n.a)
|
|
=+ d=$(a l.a)
|
|
?~ d
|
|
[n.a ~ r.a]
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a d r.a]
|
|
[n.d l.d [n.a r.d r.a]]
|
|
=+ d=$(a r.a)
|
|
?~ d
|
|
[n.a l.a ~]
|
|
?: (vor p.n.a p.n.d)
|
|
[n.a l.a d]
|
|
[n.d [n.a l.a l.d] r.d]
|
|
::
|
|
:> # %combine
|
|
+|
|
|
::
|
|
++ union
|
|
:> returns the union of {a} and {b}, preferring the value from {a} if dupe
|
|
|* [a=(dict) b=(dict)]
|
|
|- ^+ a
|
|
?~ b
|
|
a
|
|
?~ a
|
|
b
|
|
?: (vor p.n.a p.n.b)
|
|
?: =(p.n.b p.n.a)
|
|
[n.a $(a l.a, b l.b) $(a r.a, b r.b)]
|
|
?: (gor p.n.b p.n.a)
|
|
$(a [n.a $(a l.a, b [n.b l.b ~]) r.a], b r.b)
|
|
$(a [n.a l.a $(a r.a, b [n.b ~ r.b])], b l.b)
|
|
?: =(p.n.a p.n.b)
|
|
[n.b $(b l.b, a l.a) $(b r.b, a r.a)]
|
|
?: (gor p.n.a p.n.b)
|
|
$(b [n.b $(b l.b, a [n.a l.a ~]) r.b], a r.a)
|
|
$(b [n.b l.b $(b r.b, a [n.a ~ r.a])], a l.a)
|
|
::
|
|
++ union-with
|
|
:> returns the union of {a} and {b}, running {fun} to resolve duplicates.
|
|
|* [a=(dict) b=(dict) fun=$-({* *} *)]
|
|
|- ^+ a
|
|
?~ b
|
|
a
|
|
?~ a
|
|
b
|
|
?: (vor p.n.a p.n.b)
|
|
?: =(p.n.b p.n.a)
|
|
[[p.n.a (fun q.n.a q.n.b)] $(a l.a, b l.b) $(a r.a, b r.b)]
|
|
?: (gor p.n.b p.n.a)
|
|
$(a [n.a $(a l.a, b [n.b l.b ~]) r.a], b r.b)
|
|
$(a [n.a l.a $(a r.a, b [n.b ~ r.b])], b l.b)
|
|
?: =(p.n.a p.n.b)
|
|
[n.b $(b l.b, a l.a) $(b r.b, a r.a)]
|
|
?: (gor p.n.a p.n.b)
|
|
$(b [n.b $(b l.b, a [n.a l.a ~]) r.b], a r.a)
|
|
$(b [n.b l.b $(b r.b, a [n.a ~ r.a])], a l.a)
|
|
::
|
|
++ union-with-key
|
|
:> returns the union of {a} and {b}, running {fun} to resolve duplicates.
|
|
|* [a=(dict) b=(dict) fun=$-({* * *} *)]
|
|
|- ^+ a
|
|
?~ b
|
|
a
|
|
?~ a
|
|
b
|
|
?: (vor p.n.a p.n.b)
|
|
?: =(p.n.b p.n.a)
|
|
[[p.n.a (fun p.n.a q.n.a q.n.b)] $(a l.a, b l.b) $(a r.a, b r.b)]
|
|
?: (gor p.n.b p.n.a)
|
|
$(a [n.a $(a l.a, b [n.b l.b ~]) r.a], b r.b)
|
|
$(a [n.a l.a $(a r.a, b [n.b ~ r.b])], b l.b)
|
|
?: =(p.n.a p.n.b)
|
|
[n.b $(b l.b, a l.a) $(b r.b, a r.a)]
|
|
?: (gor p.n.a p.n.b)
|
|
$(b [n.b $(b l.b, a [n.a l.a ~]) r.b], a r.a)
|
|
$(b [n.b l.b $(b r.b, a [n.a ~ r.a])], a l.a)
|
|
::
|
|
:: TODO: this is untested; move it.
|
|
:: ::
|
|
:: ++ difference
|
|
:: :: todo: move real implementation here.
|
|
:: :> returns elements in {a} that don't exist in {b}.
|
|
:: |* [a=(dict) b=(dict)]
|
|
:: (~(dif by a) b)
|
|
:: ::
|
|
:: :: todo:
|
|
:: :: ++difference-with
|
|
:: :: ++difference-with-key
|
|
:: ::
|
|
:: ++ intersection
|
|
:: :: todo: move real implementation here.
|
|
:: :> returns elements in {a} that exist in {b}.
|
|
:: |* [a=(dict) b=(dict)]
|
|
:: (~(int by a) b)
|
|
:: ::
|
|
:: :: todo:
|
|
:: :: ++intersection-with
|
|
:: :: ++intersection-with-key
|
|
::
|
|
:> # %traversal
|
|
+|
|
|
::
|
|
++ map
|
|
:> applies {fun} to each value in {a}.
|
|
|* [a=(dict) fun=$-(* *)]
|
|
^- (dict _p.-.n.-.a fun)
|
|
?~ a
|
|
~
|
|
[[p.n.a (fun q.n.a)] $(a l.a) $(a r.a)]
|
|
::
|
|
++ map-with-key
|
|
:> applies {fun} to each value in {a}.
|
|
|* [a=(dict) fun=$-({* *} *)]
|
|
^- (dict _p.-.n.-.a _*fun)
|
|
?~ a
|
|
~
|
|
[[p.n.a (fun p.n.a q.n.a)] $(a l.a) $(a r.a)]
|
|
::
|
|
++ map-fold
|
|
:> performs a fold on all the values in {a}.
|
|
:>
|
|
:> lists have an order, but dicts are treaps. this means there isn't a
|
|
:> horizontal ordering, and thus the distinction between left and right
|
|
:> folding isn't relevant. your accumulator function will be called in
|
|
:> treap order.
|
|
:>
|
|
:> corresponds to {mapAccum} in haskell.
|
|
|* [a=(dict) b=* fun=$-({* *} {* *})]
|
|
^- {_b (dict _p.-.n.-.a _+:*fun)}
|
|
?~ a
|
|
[b ~]
|
|
=+ d=(fun b q.n.a)
|
|
=. q.n.a +.d
|
|
=+ e=$(a l.a, b -.d)
|
|
=+ f=$(a r.a, b -.e)
|
|
[-.f [n.a +.e +.f]]
|
|
::
|
|
++ map-keys
|
|
:> applies {fun} to all keys.
|
|
:: todo: the haskell version specifies that the "greatest" original key
|
|
:: wins in case of duplicates. this is currently unhandled. maybe i just
|
|
:: shouldn't have this gate.
|
|
|* [a=(dict) fun=$-(* *)]
|
|
%- from-list
|
|
%+ map:ls (to-list a)
|
|
|= item/_n.-.a
|
|
[(fun p.item) q.item]
|
|
::
|
|
++ map-keys-with
|
|
:> applies {fun} to all keys, creating a new value with {combine} on dupes.
|
|
|* [a=(dict) fun=$-(* *) combine=$-({* *} *)]
|
|
^- (dict _*fun _q.+.n.-.a)
|
|
=/ new-list
|
|
%+ map:ls (to-list a)
|
|
|= item/_n.-.a
|
|
[(fun p.item) q.item]
|
|
%^ foldl:ls new-list
|
|
`(dict _*fun _q.+.n.-.a)`~
|
|
|= [m=(dict _*fun _q.+.n.-.a) p=_i.-.new-list]
|
|
(put-with m -.p +.p combine)
|
|
::
|
|
++ fold
|
|
:> performs a fold on all the values in {a}.
|
|
:>
|
|
:> lists have an order, but dicts are treaps. this means there isn't a
|
|
:> horizontal ordering, and thus the distinction between left and right
|
|
:> folding isn't relevant. your accumulator function will be called in
|
|
:> treap order.
|
|
|* [a=(dict) b=* fun=$-({* *} *)]
|
|
^- _b
|
|
?~ a
|
|
b
|
|
=+ d=(fun b q.n.a)
|
|
=+ e=$(a l.a, b d)
|
|
$(a r.a, b e)
|
|
::
|
|
++ fold-with-keys
|
|
:> performs a fold on all the values in {a}, passing keys too.
|
|
|* [a=(dict) b=* fun=$-({* * *} *)]
|
|
^+ b
|
|
?~ a
|
|
b
|
|
=+ d=(fun b p.n.a q.n.a)
|
|
=+ e=$(a l.a, b d)
|
|
$(a r.a, b e)
|
|
::
|
|
++ any
|
|
:> returns yes if any element satisfies the predicate
|
|
|* [a=(dict) b=$-(* ?)]
|
|
^- ?
|
|
?~ a
|
|
%.n
|
|
?|((b q.n.a) $(a l.a) $(a r.a))
|
|
::
|
|
++ any-with-key
|
|
:> returns yes if any element satisfies the predicate
|
|
|* [a=(dict) b=$-({* *} ?)]
|
|
^- ?
|
|
?~ a
|
|
%.n
|
|
?|((b p.n.a q.n.a) $(a l.a) $(a r.a))
|
|
::
|
|
++ all
|
|
:> returns yes if all elements satisfy the predicate
|
|
|* [a=(dict) b=$-(* ?)]
|
|
^- ?
|
|
?~ a
|
|
%.y
|
|
?&((b q.n.a) $(a l.a) $(a r.a))
|
|
::
|
|
++ all-with-key
|
|
:> returns yes if all elements satisfy the predicate
|
|
|* [a=(dict) b=$-({* *} ?)]
|
|
^- ?
|
|
?~ a
|
|
%.y
|
|
?&((b p.n.a q.n.a) $(a l.a) $(a r.a))
|
|
::
|
|
:> # %conversion
|
|
+|
|
|
++ elems
|
|
:> return all values in the dict.
|
|
|* a=(dict)
|
|
%+ turn (to-list a) second
|
|
::
|
|
++ keys
|
|
:> returns all keys in the dict.
|
|
|* a=(dict)
|
|
%+ turn (to-list a) first
|
|
::
|
|
:: todo: ++assocs probably doesn't make sense when we have ++to-list and
|
|
:: when there's no general noun ordering.
|
|
::
|
|
++ keys-set
|
|
:> returns all keys as a set.
|
|
|* a=(dict)
|
|
(si:nl (keys a))
|
|
::
|
|
++ from-set
|
|
:> computes a dict by running {fun} on every value in a set.
|
|
|* [a=(set) fun=$-(* *)]
|
|
^- (dict _n.-.a _*fun)
|
|
?~ a
|
|
~
|
|
[[n.a (fun n.a)] $(a l.a) $(a r.a)]
|
|
::
|
|
:> # %lists
|
|
+|
|
|
::
|
|
++ to-list
|
|
:> creates a list of pairs from the tree.
|
|
|* a=(dict)
|
|
=| b=(list _n.-.a)
|
|
|-
|
|
^+ b
|
|
?~ a
|
|
b
|
|
$(a r.a, b [n.a $(a l.a)])
|
|
::
|
|
++ from-list
|
|
:> creates a tree from a list.
|
|
|* a=(list (pair))
|
|
|-
|
|
%^ foldl:ls a
|
|
`(dict _p.-.i.-.a _q.+.i.-.a)`~
|
|
|= [m=(dict _p.-.i.-.a _q.+.i.-.a) p=_i.-.a]
|
|
(put m p)
|
|
::
|
|
++ from-list-with
|
|
:> creates a dict from a list, with {fun} resolving duplicates.
|
|
|* [a=(list (pair)) fun=$-(* *)]
|
|
%^ foldl:ls a
|
|
`(dict _*fun _q.+.i.-.a)`~
|
|
|= [m=(dict _*fun _q.+.i.-.a) p=_i.-.a]
|
|
(put-with m -.p +.p fun)
|
|
::
|
|
:: todo: without a natural ordering, association lists and gates to operate
|
|
:: on them probably don't make sense. i'm skipping them for now.
|
|
::
|
|
:> # %filters
|
|
+|
|
|
++ filter
|
|
:> filters a dict of all values that satisfy {fun}.
|
|
|* [a=(dict) fun=$-(* ?)]
|
|
%+ filter-with-key a
|
|
|= [key=* value=_q.+.n.-.a]
|
|
(fun value)
|
|
::
|
|
++ filter-with-key
|
|
:> filters a dict of all values that satisfy {fun}.
|
|
|* [a=(dict) fun=$-({* *} ?)]
|
|
|-
|
|
^+ a
|
|
?~ a ~
|
|
?: (fun n.a)
|
|
=. l.a $(a l.a)
|
|
=. r.a $(a r.a)
|
|
(pop-top a)
|
|
[n.a $(a l.a) $(a r.a)]
|
|
::
|
|
++ restrict-keys
|
|
:> returns a dict where the only allowable keys are {keys}.
|
|
|* [a=(dict) keys=(set)]
|
|
%+ filter-with-key a
|
|
|= [key=_p.-.n.-.a value=*]
|
|
:: todo: replace this with a call to our set library when we advance that
|
|
:: far.
|
|
!(~(has in keys) key)
|
|
::
|
|
++ without-keys
|
|
:> returns a dict where the only allowable keys are not in {keys}.
|
|
|* [a=(dict) keys=(set)]
|
|
%+ filter-with-key a
|
|
|= [key=_p.-.n.-.a value=*]
|
|
:: todo: replace this with a call to our set library when we advance that
|
|
:: far.
|
|
(~(has in keys) key)
|
|
::
|
|
++ partition
|
|
:> returns two lists, one whose elements match {fun}, the other doesn't.
|
|
|* [a=(dict) fun=$-(* ?)]
|
|
:: todo: is the runtime on this is bogus?
|
|
=/ data
|
|
%+ partition:ls (to-list a)
|
|
|= p/_n.-.a
|
|
(fun q.p)
|
|
[(from-list -.data) (from-list +.data)]
|
|
::
|
|
:: todo: ++partition-with-key once ++partition works.
|
|
::
|
|
:: i'm going to ignore all the Antitone functions; they don't seem to be
|
|
:: useful without ordering on the dict.
|
|
::
|
|
++ map-maybe
|
|
:> a version of map that can throw out items.
|
|
|* [a=(dict) fun=$-(* (maybe))]
|
|
%+ map-maybe-with-key a
|
|
|= [key=* value=_q.+.n.-.a]
|
|
(fun value)
|
|
::
|
|
++ map-maybe-with-key
|
|
:> a version of map that can throw out items.
|
|
|* [a=(dict) fun=$-({* *} (maybe))]
|
|
^- (dict _p.-.n.-.a _+:*fun)
|
|
?~ a ~
|
|
=+ res=(fun n.a)
|
|
?~ res
|
|
=. l.a $(a l.a)
|
|
=. r.a $(a r.a)
|
|
(pop-top a)
|
|
[[p.n.a +.res] $(a l.a) $(a r.a)]
|
|
::
|
|
++ map-either
|
|
:> splits the dict in two on a gate that returns an either.
|
|
|* [a=(dict) fun=$-(* (either))]
|
|
%+ map-either-with-key a
|
|
|= [key=* value=_q.+.n.-.a]
|
|
(fun value)
|
|
::
|
|
++ map-either-with-key
|
|
:> splits the dict in two on a gate that returns an either.
|
|
|* [a=(dict) fun=$-({* *} (either))]
|
|
|-
|
|
^- $: (dict _p.-.n.-.a _?>(?=({{%& *} *} *fun) +:*fun))
|
|
(dict _p.-.n.-.a _?>(?=({{%| *} *} *fun) +:*fun))
|
|
==
|
|
?~ a
|
|
[~ ~]
|
|
:: todo: runtime wise, can I do better than recursive unions?
|
|
=+ lr=$(a l.a)
|
|
=+ rr=$(a r.a)
|
|
=+ x=(fun n.a)
|
|
~! x
|
|
?- -.x
|
|
$& [(put (union -.lr -.rr) p.n.a +.x) (union +.lr +.rr)]
|
|
$| [(union -.lr -.rr) (put (union +.lr +.rr) p.n.a +.x)]
|
|
==
|
|
::
|
|
:: ++split, ++split-lookup and ++split-root do not make sense without
|
|
:: ordinal keys.
|
|
::
|
|
++ is-subdict
|
|
:> returns %.y if every element in {a} exists in {b} with the same value.
|
|
|* [a=(dict) b=(dict)]
|
|
^- ?
|
|
(is-subdict-by a b |=([a=* b=*] =(a b)))
|
|
::
|
|
++ is-subdict-by
|
|
:> returns %.y if every element in {a} exists in {b} with the same value.
|
|
|* [a=(dict) b=(dict) fun=$-({* *} ?)]
|
|
|-
|
|
^- ?
|
|
?~ a %.y
|
|
?~ b %.n
|
|
~! b
|
|
~! p.n.a
|
|
=+ x=(get b p.n.a)
|
|
?~ x %.n
|
|
|((fun q.n.a u.x) $(a l.a) $(a r.a))
|
|
::
|
|
:> # %impl
|
|
:> implementation details
|
|
+|
|
|
++ pop-top
|
|
:> removes the head of the tree and rebalances the tree below.
|
|
|* a=(dict)
|
|
^- {$?($~ _a)}
|
|
?~ a ~
|
|
|-
|
|
?~ l.a r.a
|
|
?~ r.a l.a
|
|
?: (vor p.n.l.a p.n.r.a)
|
|
[n.l.a l.l.a $(l.a r.l.a)]
|
|
[n.r.a $(r.a l.r.a) r.r.a]
|
|
::
|
|
++ valid
|
|
:> returns %.y if {a} if this tree is a valid treap dict.
|
|
|* a=(tree (pair * *))
|
|
=| [l=(maybe) r=(maybe)]
|
|
|- ^- ?
|
|
?~ a &
|
|
?& ?~(l & (gor p.n.a u.l))
|
|
?~(r & (gor u.r p.n.a))
|
|
?~(l.a & ?&((vor p.n.a p.n.l.a) $(a l.a, l `p.n.a)))
|
|
?~(r.a & ?&((vor p.n.a p.n.r.a) $(a r.a, r `p.n.a)))
|
|
==
|
|
--
|
|
++ random
|
|
:> produces a core which produces random numbers.
|
|
:>
|
|
:> random numbers are generated through repeated sha-256 operations.
|
|
:>
|
|
:> this design forces implementation details to be hidden, forces users to
|
|
:> go through =^. this should be less error prone for pulling out multiple
|
|
:> random numbers, at the cost of making getting a single random number
|
|
:> slightly more cumbersome.
|
|
:>
|
|
:> =+ gen=(random eny)
|
|
:> =^ first gen (range:gen 0 10)
|
|
:> =^ second gen (range:gen 0 10)
|
|
|= a=@
|
|
=> |%
|
|
++ raw :: random bits
|
|
|= b=@ ^- @
|
|
%+ can
|
|
0
|
|
=+ c=(shas %og-a (mix b a))
|
|
|- ^- (list {@ @})
|
|
?: =(0 b)
|
|
~
|
|
=+ d=(shas %og-b (mix b (mix a c)))
|
|
?: (lth b 256)
|
|
[[b (end 0 b d)] ~]
|
|
[[256 d] $(c d, b (sub b 256))]
|
|
::
|
|
++ rad :: random in range
|
|
|= b=@ ^- @
|
|
=+ c=(raw (met 0 b))
|
|
?:((lth c b) c $(a +(a)))
|
|
--
|
|
^? |%
|
|
++ range
|
|
:> returns a random number in the range [start, end], and generator.
|
|
|= [start=@ end=@]
|
|
?: (gte start end)
|
|
~_(leaf+"invalid range" !!)
|
|
=+ offset=(sub end start)
|
|
=+ r=(rad offset)
|
|
[(add start r) +>.$(a (shas %og-s (mix a r)))]
|
|
::
|
|
++ bits
|
|
:> returns {b} bits in the range, and generator.
|
|
|= b=@
|
|
=+ r=(raw b)
|
|
[r +>.$(a (shas %og-s (mix a r)))]
|
|
--
|
|
--
|