2j: Jar and Jug Logic

    ++ja

    Jar engine

          |_  a=(jar)
    

    A container arm for ++jar operation arms. A ++jar is a ++map of ++lists. The contained arms inherit the sample jar.

    a is a jar.

        > ~(. ja (mo (limo a/"ho" b/"he" ~)))
        <2.dgz [nlr([p={%a %b} q=""]) <414.fvk 101.jzo 1.ypj %164>]>
    

    +-get:ja

    Grab value by key

          +-  get                                               ::  gets list by key
            |*  b=*
            =+  c=(~(get by a) b)
            ?~(c ~ u.c)
    

    Accepts

    a is a ++jar.

    b is a key of the same type as the keys in a.

    Produces

    A list retrieved from jar a using the key b.

    Examples

        > =l (mo `(list ,[@t (list ,@)])`[['a' `(list ,@)`[1 2 3 ~]] ['b' `(list ,@)`[4 5 6 ~]] ~])
        > l
        [[p='a' q=~[1 2 3]] [p='b' q=~[4 5 6]]}
    
        > (~(get ja l) 'a')
        ~[1 2 3]
    
        > (~(get ja l) 'b')
        ~[4 5 6]
    
        > (~(get ja l) 'c')
        ~
    

    +-add:ja

    Prepend to list

    Source

          +-  add                                               ::  adds key-list pair
            |*  [b=* c=*]
            =+  d=(get b)
            (~(put by a) b [c d])
    

    Accepts

    a is a jar.

    b is a key of the same type as the keys in a.

    c is a value of the same type as the values in a.

    Examples

        > =l (mo `(list ,[@t (list ,@)])`[['a' `(list ,@)`[1 2 3 ~]] ['b' `(list ,@)`[4 5 6 ~]] ~])
        > l
        {[p='a' q=~[1 2 3]] [p='b' q=~[4 5 6]]}
    
        > (~(add ja l) 'b' 7)
        {[p='a' q=~[1 2 3]] [p='b' q=~[7 4 5 6]]}
    
        > (~(add ja l) 'a' 100)
        {[p='a' q=~[100 1 2 3]] [p='b' q=~[4 5 6]]}
    
        > (~(add ja l) 'c' 7)
        {[p='a' q=~[1 2 3]] [p='c' q=~[7]] [p='b' q=~[4 5 6]]}
    
        > (~(add ja l) 'c' `(list ,@)`[7 8 9 ~])
        ! type-fail
        ! exit
    

    **

    ++ju

    Jug operations

        ++  ju                                                  ::  jug engine
          |/  a=(jug)
    

    Container arm for jug operation arms. A ++jug is a ++map of ++sets. The contained arms inherit its sample jug, a.

    a is a jug.

        > ~(. ju (mo (limo a=(sa "ho") b=(sa "he") ~)))
        <2.dgz [nlr([p={%a %b} q={nlr(^$1{@tD $1}) nlr(^$3{@tD $3})}]) <414.fvk 101.jzo 1.ypj %164>]>
    

    +-del:ju

    Remove

    Source

          +-  del                                               ::  del key-set pair
            |*  [b=* c=*]
            ^+  a
            =+  d=(get b)
            =+  e=(~(del in d) c)
            ?~  e
              (~(del by a) b)
            (~(put by a) b e)
          ::
    

    Produces jug a with value c removed from set located at key b.

    a is a jug.

    b is a key of the same type as the keys in a.

    c is the value of the same type of the keys in a that is to be removed.

        > s
        [[p='a' q={1 3 2}] [p='b' q={5 4 6}]}
    
        > (~(del ju s) 'a' 1)
        {[p='a' q={3 2}] [p='b' q={5 4 6}]}
    
        > (~(del ju s) 'c' 7)
        {[p='a' q={1 3 2}] [p='b' q={5 4 6}]}
    

    +-get:ju

    Retrieve set

          +-  get                                               ::  gets set by key
            |*  b=*
            =+  c=(~(get by a) b)
            ?~(c ~ u.c)
          ::
    

    Produces a set retrieved from jar a using key b.

    a is a jar.

    b is a key of the same type as the keys in a.

        > s
        {[p='a' q={1 3 2}] [p='b' q={5 4 6}]}
        > (~(get ju s) 'a')
        {1 3 2}
        > (~(get ju s) 'b')
        {5 4 6}
        > (~(get ju s) 'c')
        ~
    

    +-has:ju

    Check contents

          +-  has                                               ::  existence check
            |*  [b=* c=*]
            ^-  ?
            (~(has in (get b)) c)
          ::
    

    Computes whether a value c exists within the set located at key b with jar a. Produces a loobean.

    a is a set.

    b is a key as a noun.

    c is a value as a noun.

        > s
        {[p='a' q={1 3 2}] [p='b' q={5 4 6}]}
        > (~(has ju s) 'a' 3)
        %.y
        > (~(has ju s) 'b' 6)
        %.y
        > (~(has ju s) 'a' 7)
        %.n
        > (~(has jus s) 'c' 7)
        ! -find-limb.jus
        ! find-none
        ! exit
        > (~(has ju s) 'c' 7)
        %.n
    

    +-put:ju

    Add key-set pair

          +-  put
            |*  {b=* c=*}
            ^+  a
            =+  d=(get b)
            (~(put by a) b (~(put in d) c))
    

    Produces jar a with c added to the set value located at key b.

    a is a set.

    b is a key as a noun.

    c is a value.

        > s
        [p='a' q=[1 3 2]] [p='b' q=[5 4 6]]]
    
        > (~(put ju s) 'a' 7)
        {[p='a' q={7 1 3 2}] [p='b' q={5 4 6}]}
    
        > (~(put ju s) 'a' 1)
        {[p='a' q={1 3 2}] [p='b' q={5 4 6}]}
    
        > (~(put ju s) 'c' 7)
        {[p='a' q={1 3 2}] [p='c' q={7}] [p='b' q={5 4 6}]}