Buffer (clj)

    End users should use typed.lib.clojure.core.async, which all types here
    are qualified under."}
  typed.ann.clojure.core.async
  (:require [typed.clojure :refer [ann ann-datatype defalias ann-protocol] :as t]
            [typed.lib.clojure.core.async :as-alias ta]
            [clojure.core.async.impl.protocols :as-alias impl])
  (:import (java.util.concurrent.locks Lock)))

(ann-protocol [[w :variance :contravariant]
               [r :variance :covariant]]
               clojure.core.async.impl.protocols/Buffer
               full? [(impl/Buffer w r) :-> t/Any]
               remove! [(impl/Buffer w r) :-> nil]
               add!* [(impl/Buffer w r) w :-> (impl/Buffer w r)])

(ann-protocol clojure.core.async.impl.protocols/UnblockingBuffer)

(defalias 
  ^{:forms '[(Buffer2 t t)]}
  ta/Buffer2
  "A buffer of that can write type w and read type t."
  (t/TFn [[w :variance :contravariant]
          [r :variance :covariant]]
         (t/I (impl/Buffer w r)
              clojure.lang.Counted)))

(defalias 
  ^{:forms '[(Buffer t)]}
  ta/Buffer
  "A buffer of type x."
  (t/TFn [[x :variance :invariant]]
         (ta/Buffer2 x x)))

(defalias 
  ^{:forms '[(UnblockingBuffer2 t t)]}
  ta/UnblockingBuffer2
  "An unblocking buffer that can write type w and read type t."
  (t/TFn [[w :variance :contravariant]
          [r :variance :covariant]]
         (t/I (ta/Buffer2 w r)
              impl/UnblockingBuffer)))

(defalias 
  ^{:forms '[(UnblockingBuffer t)]}
  ta/UnblockingBuffer
  "An unblocking buffer of type x."
  (t/TFn [[x :variance :invariant]]
         (ta/UnblockingBuffer2 x x)))

(ann ^:no-check clojure.core.async/buffer (t/All [t] [t/Int :-> (ta/Buffer t)]))
(ann ^:no-check clojure.core.async/dropping-buffer (t/All [t] [t/Int :-> (ta/Buffer t)]))
(ann ^:no-check clojure.core.async/sliding-buffer (t/All [t] [t/Int :-> (ta/Buffer t)]))

; TODO buffer must be supplied when xform is
(ann ^:no-check clojure.core.async/chan
     (t/All [p t]
            (t/IFn [:-> (ta/Chan2 p t)]
                   [; buf-or-n
                    (t/U (ta/Buffer2 p t) t/Int nil) :-> (ta/Chan2 p t)]
                   [; buf-or-n
                    (t/U (ta/Buffer2 p t) t/Int nil)
                    ; xform
                    (t/U nil (t/Transducer p t))
                    ; ex-handler
                    (t/U nil [Throwable :-> (t/U nil p)])
                    :?
                    :-> (ta/Chan2 p t)])))

(ns com.walmartlabs.lacinia.pedestal.spec
  "Common specifications."
  {:added "0.10.0"}
  (:require
    com.walmartlabs.lacinia.schema                          ; for CompiledSchema
    [clojure.core.async.impl.protocols :refer [Buffer]]
    io.pedestal.interceptor                                 ; for Interceptor
    [clojure.spec.alpha :as s])
  (:import
    (com.walmartlabs.lacinia.schema CompiledSchema)
    (io.pedestal.interceptor Interceptor)))

(s/def ::buffer-or-n (s/or :buffer #(satisfies? Buffer %)
                           :n pos-int?))