skeptic.examples — org.clojars.nomicflux/skeptic 0.7.0

flat-maybe-base-type-failure clj

(flat-maybe-base-type-failure flag)

flat-maybe-multi-step-f clj

(flat-maybe-multi-step-f flag)

Inputs: [flag] Returns: (s/maybe s/Int)

flat-maybe-multi-step-g clj

(flat-maybe-multi-step-g flag)

Inputs: [flag] Returns: (s/maybe s/Int)

flat-maybe-nil-failure clj

(flat-maybe-nil-failure flag)

flat-maybe-success clj

(flat-maybe-success flag)

int-add clj

(int-add x)

(int-add x y)

(int-add x y & zs)

Inputs: ([x :- s/Int] [x :- s/Int y :- s/Int] [x :- s/Int y :- s/Int & zs :- [s/Int]]) Returns: s/Int

m clj

maybe-multi-step-takes-int clj

(maybe-multi-step-takes-int x)

Inputs: [x :- s/Int] Returns: s/Int

maybe-multi-step-takes-maybe-int clj

(maybe-multi-step-takes-maybe-int x)

Inputs: [x :- (s/maybe s/Int)] Returns: (s/maybe s/Int)

maybe-multi-step-takes-str clj

(maybe-multi-step-takes-str x)

Inputs: [x :- (s/maybe s/Str)] Returns: (s/maybe s/Str)

MaybeValueDesc clj

mismatched-maybe-annotation clj

(mismatched-maybe-annotation x)

Inputs: [x :- (s/maybe s/Int)] Returns: s/Str

Another function. This one may not work.

mismatched-wrong-annotation clj

(mismatched-wrong-annotation x)

Inputs: [x :- s/Str] Returns: s/Str

This one definitely won't work.

multiple-arities clj

(multiple-arities x)

(multiple-arities y z)

Inputs: ([x :- s/Int] [y :- (s/maybe s/Int) z :- s/Int]) Returns: s/Str

multiple-arities-basic clj

(multiple-arities-basic)

(multiple-arities-basic x)

(multiple-arities-basic x & y)

multiple-arities-with-annotations clj

(multiple-arities-with-annotations)

(multiple-arities-with-annotations x)

(multiple-arities-with-annotations x y)

(multiple-arities-with-annotations x y & z)

Inputs: ([] [x :- s/Int] [x y] [x :- s/Int y :- s/Int & z :- [s/Int]]) Returns: s/Int

n clj

nested-maybe-base-type-failure clj

(nested-maybe-base-type-failure flag)

nested-maybe-multi-step-f clj

(nested-maybe-multi-step-f flag)

Inputs: [flag] Returns: MaybeValueDesc

nested-maybe-multi-step-g clj

(nested-maybe-multi-step-g flag)

Inputs: [flag] Returns: MaybeValueDesc

nested-maybe-nil-failure clj

(nested-maybe-nil-failure flag)

nested-maybe-success clj

(nested-maybe-success flag)

optional-args clj

(optional-args x & others)

Inputs: [x :- s/Int & others] Returns: s/Str

sample-annotated-bad-fn clj

(sample-annotated-bad-fn x)

Inputs: [x :- s/Int] Returns: s/Int

sample-bad-fn clj

(sample-bad-fn x)

sample-bad-let-fn clj

(sample-bad-let-fn x)

sample-let-bad-fn clj

(sample-let-bad-fn x)

sample-let-mismatched-types clj

(sample-let-mismatched-types x)

sample-multi-line-let-body clj

(sample-multi-line-let-body x)

with-annotated-anonymous-function clj

(with-annotated-anonymous-function z)

with-annotated-input clj

(with-annotated-input x)

Inputs: [x :- s/Int]

with-annotated-output clj

(with-annotated-output x)

Inputs: [x] Returns: s/Str

with-annotations clj

(with-annotations x)

Inputs: [x :- s/Int] Returns: s/Str

with-let-plain clj

(with-let-plain x)

with-let-variables clj

(with-let-variables z)

Inputs: [z :- s/Int]

with-multiple-args-and-function-call clj

(with-multiple-args-and-function-call x y)

Inputs: [x :- s/Int y :- s/Bool] Returns: s/Str

Another function.

with-one-annotated-input clj

(with-one-annotated-input x y)

Inputs: [x :- s/Int y]