array.egi

;;
;; Array.egi
;;

(define $Array
  (lambda [$a]
    (type
      {[<cons ,$key ,$val _> [(Array a)]
        {[$arr (if (and (array-range? key arr)
                        ((= a) (array-ref key arr) val))
                   {[arr]}
                   {})]}]
       [<cons ,$key _ _> [a (Array a)]
        {[$arr (if (array-range? key arr)
                   {[(array-ref key arr) arr]}
                   {})]}]
       [_ [Something]
        {[$tgt {[tgt]}]}]
       })))

(define $range-to-keys
  (lambda $ms
    (letrec {[$range-to-keys2
              (lambda [$ms]
                (match ms (List Integer)
                  {[<nil> {{}}]
                   [<cons $n $ns>
                    (let {[$iss (range-to-keys2 ns)]}
                      (concat (map (lambda [$i]
                                     (map (lambda [$is] {i @is})
                                          iss))
                                   (between 1 n))))]}))]}
      (map collection-to-tuple (range-to-keys2 (tuple-to-collection ms))))))

(define $keys-for-display
  (lambda [$mx $my]
    (let {[$xs (between 1 mx)]
          [$ys (reverse (between 1 my))]}
      (map (lambda [$y]
             (map (lambda [$x] [x y])
                  xs))
           ys))))

(define $find-from-value
  (lambda [$a]
    (lambda [$val $arr]
      (let {[$keys (array-keys arr)]}
        (letrec {[$helper (lambda [$keys]
                            (if ((= a) (array-ref (car keys) arr) val)
                                (car key)
                                (helper (cdr keys))))]}
          (helper keys))))))

(define $find-all-from-value
  (lambda [$a]
    (lambda [$val $arr]
      (let {[$keys (array-keys arr)]}
        (letrec {[$helper (lambda [$keys $ret]
                            (match keys (List Something)
                              {[<nil> ret]
                               [<cons $key $rest>
                                (if ((= a) (array-ref key arr) val)
                                    (helper rest {@ret val})
                                    (helper rest ret))]}))]}
          (helper keys {}))))))

(define $find-from-value-with-pattern
  (lambda [$a]
    (lambda [$pat $arr]
      (let {[$keys (array-keys arr)]}
        (letrec {[$helper (lambda [$keys]
                            (match (array-ref (car keys) arr) a
                              {[pat (car keys)]
                               [_ (helper (cdr keys))]}))]}
          (helper keys))))))

(define $find-all-from-value-with-pattern
  (lambda [$a]
    (lambda [$pat $arr]
      (let {[$keys (array-keys arr)]}
        (letrec {[$helper (lambda [$keys $ret]
                            (match keys (List Something)
                              {[<nil> ret]
                               [<cons $key $rest>
                                (match (array-ref key arr) a
                                  {[pat (helper rest {@ret val})]
                                   [_ (helper rest ret)]})]}))]}
          (helper keys {}))))))