reprovide call from mischief/function

function.rkt

@@ -53,6 +53,7 @@
          app
          gen:application-scheme
          application-scheme/c
+         call
          (contract-out
           [application-scheme? (predicate/c)]
           [unthunk (binary-variadic-function/c procedure? any/c procedure?)]
@@ -122,6 +123,14 @@
           [negate (function/c procedure? function?)]
           [!! (function/c procedure? function?)]))
 
+;; from mischief/function - reproviding it via require+provide runs aground
+;; of some "name is protected" error while building docs, not sure why;
+;; so including the implementation directly here for now
+(define call
+  (make-keyword-procedure
+   (lambda (ks vs f . xs)
+     (keyword-apply f ks vs xs))))
+
 (define (unthunk f . args)
   (f:thunk*
    (apply f args)))

scribblings/function.scrbl

@@ -20,6 +20,7 @@
                     (only-in racket/generator sequence->generator)
                     (prefix-in b: racket/function)
                     arguments
+					(only-in mischief/function (call m:call))
                     (prefix-in f: data/functor)]]
 
 @(define eval-for-docs
@@ -427,6 +428,24 @@ This module provides general-purpose utilities to support programming in the @hy
   ]
 }
 
+@deftogether[(
+@defproc[(call [g procedure?]
+               [v any/c]
+               ...)
+         procedure?]
+  )]{
+
+ Reprovided from @racketlink[m:call]{@racket[call]}. This simply makes standard function invocation available as a function, for use in cases where we cannot directly (i.e. syntactically) invoke the function.
+ This function is in some respects similar to the @hyperlink["https://typeclasses.com/featured/dollar"]{@racket[$] operator} in Haskell.
+
+@examples[
+    #:eval eval-for-docs
+    (call + 1 2 3 4)
+    (call = #:key string-upcase "Apple" "APPLE")
+    (map call (list add1 sqr) (list 2 3))
+  ]
+}
+
 @section[#:tag "function:types"]{Types}
 
 @subsection{Functions and Composition}