Module Stdlib.Fun
Contents
Instructions: Use this module in your project
In the IDE (CLion, Visual Studio Code, Xcode, etc.) you use for your DkSDK project:
Add the following to your project's
dependencies/CMakeLists.txt:DkSDKProject_DeclareAvailable(ocaml CONSTRAINT "= 4.14.0" FINDLIBS str unix runtime_events threads dynlink) DkSDKProject_MakeAvailable(ocaml)Add the
Findlib::ocamllibrary to any desired targets insrc/*/CMakeLists.txt:target_link_libraries(YourPackage_YourLibraryName # ... existing libraries, if any ... Findlib::ocaml)Click your IDE's
Buildbutton
Not using DkSDK?
FIRST, do one or all of the following:
Run:
opam install ocaml.4.14.0Edit your
dune-projectand add:(package (name YourExistingPackage) (depends ; ... existing dependenices ... (ocaml (>= 4.14.0))))Then run:
dune build *.opam # if this fails, run: dune buildEdit your
<package>.opamfile and add:depends: [ # ... existing dependencies ... "ocaml" {>= "4.14.0"} ]Then run:
opam install . --deps-only
FINALLY, add the library to any desired (library)and/or (executable) targets in your **/dune files:
(library
(name YourLibrary)
; ... existing library options ...
(libraries
; ... existing libraries ...
))
(executable
(name YourExecutable)
; ... existing executable options ...
(libraries
; ... existing libraries ...
))Combinators
valid :'a->'a
id is the identity function. For any argument x, id x is x.
valconst :'a->_->'a
const c is a function that always returns the value c. For any
argument x, (const c) x is c.
valflip : ``('a->'b->'c)``->'b->'a->'c
flip f reverses the argument order of the binary function f. For any
arguments x and y, (flip f) x y is f y x.
valnegate : ``('a->bool)``->'a->bool
negate p is the negation of the predicate function p. For any
argument x, (negate p) x is not (p x).
Exception handling
valprotect : ``finally:``(``unit->unit)``->``(``unit->'a)``->'a
protect ~finally work invokes work () and then finally () before
work () returns with its value or an exception. In the latter case the
exception is re-raised after finally (). If finally () raises an
exception, then the exception
Finally_raised is raised instead.
protect can be used to enforce local invariants whether work ()
returns normally or raises an exception. However, it does not protect
against unexpected exceptions raised inside finally () such as
Stdlib.Out_of_memory,
Stdlib.Stack_overflow, or
asynchronous exceptions raised by signal handlers (e.g.
Sys.Break).
Note: It is a programming error if other kinds of exceptions are
raised by finally, as any exception raised in work () will be lost
in the event of a Finally_raised
exception. Therefore, one should make sure to handle those inside the
finally.
exceptionFinally_raisedofexn
Finally_raised exn is raised by protect ~finally work when finally
raises an exception exn. This exception denotes either an unexpected
exception or a programming error. As a general rule, one should not
catch a Finally_raised exception except as part of a catch-all
handler.
