check-errors

Argument checks & errors.

Documentation

Usage

(import check-errors)

Everything.

Check Error Basic

The type-checks-basic & type-errors-basic module reexports.

Usage

(import (check-errors basic))

The minimum.

Argument Conventions

LOC: (or symbol false). The symbolic naming of the location detecting the problem. As in the error form.
OBJ: *
ARGNAM: (or symbol false) naming the argument list element corresponding to the OBJ. The default is the type-name.

Type Checks

Performs the minimal constraint check and raises an error condition upon failure. The mimimal constraint proviso is important for understanding the behavior of the checking routines. Unless otherwise specified no additional constraints are verified.

So the check-...-interval routines, for example, do not verify the types of the arguments, only the interval constraint.

When the unsafe feature is defined the check procedures are no-ops.

All check-... routines return the checked object.

Usage

(import type-checks)

Type Checks Basic

Usage

(import type-checks-basic)

check-defined-value

[procedure] (check-defined-value LOC OBJ [ARGNAM]) -> *

Ensures the OBJ is non-void, i.e. not an undefined-value.

check-bound-value

[procedure] (check-bound-value LOC OBJ [ARGNAM]) -> *

Ensures the OBJ is the value of a bound variable.

Only for use in rather unsafe calling environments where some explicit checking is necessary.

check-minimum-argument-count

[procedure] (check-minimum-argument-count LOC ARGC MINARGC) -> fixnum

Does not verify the type of ARGC, and MINARGC.

check-argument-count

[procedure] (check-argument-count LOC ARGC MAXARGC) -> fixnum

Does not verify the type of ARGC, and MAXARGC.

define-check-type

define-check-type/type

(define-check-type TYPNAM [TYPE-PRED])(define-check-type/type TYPNAM [TYPE-PRED])

Creates a procedure definition for check-TYPNAM with the signature of the above check procedures. The type-predicate is either TYPE-PRED, when present, or TYPNAM?. The define-check-type/type variant adds a procedure type signature.

TYPNAM: symbol
TYPE-PRED: procedure

(define-check-type hash-table)
;=>
;(define (check-hash-table loc obj #!optional argnam)
;  (unless (hash-table? obj)
;    (error-hash-table loc obj argnam))
;  obj )

define-check+error-type

define-check+error-type/type

(define-check+error-type TYPNAM [TYPE-PRED [TYPSIG]])(define-check+error-type/type TYPNAM [TYPE-PRED [TYPSIG]])

Creates a procedure definition for check-TYPNAM with the signature of the above check procedures. The type-predicate is either TYPE-PRED, when present, or TYPE?. The error message type-name is either the TYPSIG, when present, or TYPNAM. The define-check+error-type/type variant adds a procedure type signature.

TYPNAM: symbol
TYPE-PRED: procedure
TYPSIG: (or symbol (list-of TYPSIG))

(define-check+error-type hash-table)
;=>
;(begin
;  (define-error-type hash-table)
;  (define (check-hash-table loc obj #!optional argnam)
;    (unless (hash-table? obj)
;      (error-hash-table loc obj argnam))
;    obj))

Type Checks Numbers

Omnibus module vovering the individual type-checks-numbers modules below.

Usage

(import type-checks-numbers)

check-real

check-complex

check-rational

check-exact

check-inexact

(import (type-checks-numbers scheme))

(check-real LOC OBJ [ARGNAM]) -> number(check-complex LOC OBJ [ARGNAM]) -> number(check-rational LOC OBJ [ARGNAM]) -> number(check-exact LOC OBJ [ARGNAM]) -> number(check-inexact LOC OBJ [ARGNAM]) -> number

check-number

check-positive-number

check-non-negative-number

check-natural-number

check-negative-number

check-non-positive-number

(import (type-checks-numbers number))

(check-number LOC OBJ [ARGNAM]) -> number(check-positive-number LOC OBJ [ARGNAM]) -> number(check-non-negative-number LOC OBJ [ARGNAM]) -> number(check-natural-number LOC OBJ [ARGNAM]) -> number(check-negative-number LOC OBJ [ARGNAM]) -> number(check-non-positive-number LOC OBJ [ARGNAM]) -> number

check-integer

check-positive-integer

check-non-negative-integer

check-natural-integer

check-negative-integer

check-non-positive-integer

(import (type-checks-numbers integer))

(check-integer LOC OBJ [ARGNAM]) -> integer(check-positive-integer LOC OBJ [ARGNAM]) -> integer(check-non-negative-integer LOC OBJ [ARGNAM]) -> integer(check-natural-integer LOC OBJ [ARGNAM]) -> integer(check-negative-integer LOC OBJ [ARGNAM]) -> integer(check-non-positive-integer LOC OBJ [ARGNAM]) -> integer

check-fixnum

check-positive-fixnum

check-non-negative-fixnum

check-natural-fixnum

check-negative-fixnum

check-non-positive-fixnum

(import (type-checks-numbers fixnum))

(check-fixnum LOC OBJ [ARGNAM]) -> fixnum(check-positive-fixnum LOC OBJ [ARGNAM]) -> fixnum(check-non-negative-fixnum LOC OBJ [ARGNAM]) -> fixnum(check-natural-fixnum LOC OBJ [ARGNAM]) -> fixnum(check-negative-fixnum LOC OBJ [ARGNAM]) -> fixnum(check-non-positive-fixnum LOC OBJ [ARGNAM]) -> fixnum

check-bignum

check-positive-bignum

check-non-negative-bignum

check-negative-bignum

check-non-positive-bignum

(import (type-checks-numbers bignum))

(check-bignum LOC OBJ [ARGNAM]) -> bignum(check-positive-bignum LOC OBJ [ARGNAM]) -> bignum(check-non-negative-bignum LOC OBJ [ARGNAM]) -> bignum(check-negative-bignum LOC OBJ [ARGNAM]) -> bignum(check-non-positive-bignum LOC OBJ [ARGNAM]) -> bignum

check-ratnum

check-positive-ratnum

check-non-positive-bignum

check-negative-ratnum

check-non-positive-ratnum

(import (type-checks-numbers ratnum))

(check-ratnum LOC OBJ [ARGNAM]) -> ratnum(check-positive-ratnum LOC OBJ [ARGNAM]) -> ratnum(check-non-negative-ratnum LOC OBJ [ARGNAM]) -> ratnum(check-negative-ratnum LOC OBJ [ARGNAM]) -> ratnum(check-non-positive-ratnum LOC OBJ [ARGNAM]) -> ratnum

check-flonum

check-float

check-positive-flonum

check-non-positive-flonum

check-negative-flonum

check-non-positive-flonum

(import (type-checks-numbers flonum))

(check-flonum LOC OBJ [ARGNAM]) -> flonum(check-float LOC OBJ [ARGNAM]) -> flonum(check-positive-flonum LOC OBJ [ARGNAM]) -> flonum(check-non-negative-flonum LOC OBJ [ARGNAM]) -> flonum(check-negative-flonum LOC OBJ [ARGNAM]) -> flonum(check-non-positive-flonum LOC OBJ [ARGNAM]) -> flonum

check-cplxnum

(import (type-checks-numbers cplxnum))

[procedure] (check-cplxnum LOC OBJ [ARGNAM]) -> cplxnum

Type Checks Numbers Interval

Usage

(import (type-checks-numbers interval))

check-range

[procedure] (check-range LOC START END [ARGNAM]) -> number number

Verify (<= START END) & return (values START END).

Does not verify the type of START and END.

check-open-interval

[procedure] (check-open-interval LOC NUM MINNUM MAXNUM [ARGNAM]) -> number

NUM in ]MINNUM MAXNUM[.

Does not verify the type of NUM, MINNUM, and MAXNUM.

check-closed-interval

[procedure] (check-closed-interval LOC NUM MINNUM MAXNUM [ARGNAM]) -> number

NUM in [MINNUM MAXNUM].

Does not verify the type of NUM, MINNUM, and MAXNUM.

check-half-open-interval

[procedure] (check-half-open-interval LOC NUM MINNUM MAXNUM [ARGNAM]) -> number

NUM in ]MINNUM MAXNUM].

Does not verify the type of NUM, MINNUM, and MAXNUM.

check-half-closed-interval

[procedure] (check-half-closed-interval LOC NUM MINNUM MAXNUM [ARGNAM]) -> number

NUM in [MINNUM MAXNUM[.

Does not verify the type of NUM, MINNUM, and MAXNUM.

Type Checks Structured

Usage

(import type-checks-structured)

check-procedure

[procedure] (check-procedure LOC OBJ [ARGNAM]) -> procedure

check-input-port

[procedure] (check-input-port LOC OBJ [ARGNAM]) -> input-port

check-output-port

[procedure] (check-output-port LOC OBJ [ARGNAM]) -> output-port

check-list

[procedure] (check-list LOC OBJ [ARGNAM]) -> list

check-alist

[procedure] (check-alist LOC OBJ [ARGNAM]) -> alist

check-plist

[procedure] (check-plist LOC OBJ [ARGNAM]) -> plist

check-pair

[procedure] (check-pair LOC OBJ [ARGNAM]) -> pair

check-blob

[procedure] (check-blob LOC OBJ [ARGNAM]) -> blob

check-vector

[procedure] (check-vector LOC OBJ [ARGNAM]) -> vector

check-structure

(check-structure LOC OBJ TAG [ARGNAM]) -> structure(check-record LOC OBJ TAG [ARGNAM]) -> structure(check-record-type LOC OBJ TAG [ARGNAM]) -> structure

Essentially synonyms.

define-check-structure

[syntax] (define-check-structure TAG)

Creates a procedure definition for check-TAG with the signature of the above check procedures, and the body of (check-structure LOC OBJ TAG [ARGNAM]).

check-string

[procedure] (check-string LOC OBJ [ARGNAM]) -> string

Type Checks Atoms

Usage

(import type-checks-atoms)

check-symbol

[procedure] (check-symbol LOC OBJ [ARGNAM]) -> symbol

check-keyword

[procedure] (check-keyword LOC OBJ [ARGNAM]) -> keyword

check-char

[procedure] (check-char LOC OBJ [ARGNAM]) -> char

check-boolean

[procedure] (check-boolean LOC OBJ [ARGNAM]) -> boolean

Type Checks SRFI-4

Usage

(import srfi-4-checks)

check-s8vector

check-u8vector

check-s16vector

check-u16vector

check-s32vector

check-u32vector

check-s64vector

check-u64vector

check-f32vector

check-f64vector

(check-s8vector LOC OBJ [ARGNAM]) -> *(check-u8vector LOC OBJ [ARGNAM]) -> *(check-s16vector LOC OBJ [ARGNAM]) -> *(check-u16vector LOC OBJ [ARGNAM]) -> *(check-s32vector LOC OBJ [ARGNAM]) -> *(check-u32vector LOC OBJ [ARGNAM]) -> *(check-s64vector LOC OBJ [ARGNAM]) -> *(check-u64vector LOC OBJ [ARGNAM]) -> *(check-f32vector LOC OBJ [ARGNAM]) -> *(check-f64vector LOC OBJ [ARGNAM]) -> *

Type Errors

Argument Conventions

TYPNAM: symbol, unless otherwise indicated.
ARGNAM: (or symbol false), default is #f.

Usage

(import type-errors)

Type Errors Basic

Usage

(import type-errors-basic)

make-bad-argument-message

[procedure] (make-bad-argument-message [ARGNAM]) -> string

Returns an argument type error message for the, optional, ARGNAM.

Example:

(make-bad-argument-message "count")
;=> "bad `count' argument"
(make-bad-argument-message)
;=> "bad argument"

make-type-name-message

[procedure] (make-type-name-message TYPNAM) -> string

Returns an argument type message for the TYPNAM by supplying an article.

Example:

(make-type-name-message integer) ;=> an integer"
(make-type-name-message "symbol in {foo bar baz}")
;=> "a symbol in {foo bar baz}"

make-error-type-message

[procedure] (make-error-type-message TYPNAM [ARGNAM]) -> string

Returns a type error message from the TYPNAM and optional ARGNAM.

Uses make-bad-argument-message and make-type-name-message to build the message components.

Example:

(make-error-type-message 'integer "count")
;=> "bad `count' argument type - not an integer"

make-location-message

[procedure] (make-location-message LOC) -> string

make-warning-type-message

[procedure] (make-warning-type-message LOC OBJ TYPNAM [ARGNAM]) -> string

make-error-interval-message

[procedure] (make-error-interval-message LFT MIN MAX RGT [ARGNAM]) -> string

signal-bounds-error

[procedure] (signal-bounds-error LOC MSG OBJ...)

Raises a non-continuable type error - (({exn bounds)}}.

signal-type-error

[procedure] (signal-type-error LOC MSG OBJ...)

Raises a non-continuable type error - (({exn type)}}.

error-argument-type

[procedure] (error-argument-type LOC OBJ TYPNAM [ARGNAM])

Raises a type-error where is message is constructed from the TYPNAM and ARGNAM.

Uses signal-type-error and make-error-type-message.

warning-argument-type

[procedure] (warning-argument-type LOC OBJ TYPNAM [ARGNAM])

A warning is issued with a message similar to that of error-argument-type.

error-defined-value

[procedure] (error-defined-value LOC OBJ [ARGNAM])

error-bound-value

[procedure] (error-bound-value LOC OBJ [ARGNAM])

error-minimum-argument-count

[procedure] (error-minimum-argument-count LOC ARGC MINARGC)

error-argument-count

[procedure] (error-argument-count LOC ARGC MAXARGC)

define-error-type

define-error-type/type

(define-error-type TYPNAM [TYPSIG])(define-error-type/type TYPNAM [TYPSIG])

TYPNAM: symbol
TYPSIG: (or symbol (list-of TYPSIG))

Creates a procedure definition for error-TYPNAM with the signature of the above error procedures. The type-name is either TYPSIG, when present, or TYPNAM. The define-check+error-type/type variant adds a procedure type signature.

(define-error-type hash-table)
;=>
;(define (error-hash-table loc obj #!optional argnam)
;  (error-argument-type loc obj 'hash-table argnam) )

(define-error-type byte-order "symbol in {big-endian little-endian}")
;=>
;(define (error-byte-order loc obj #!optional argnam)
;  (error-argument-type loc obj "symbol in {big-endian little-endian}" argnam) )

Type Errors Numbers

Omnibus module vovering the individual type-errors-numbers modules below.

Usage

(import type-errors-numbers)

error-real

error-complex

error-rational

error-exact

error-inexact

(import (type-errors-numbers scheme))

(error-real LOC OBJ [ARGNAM])(error-complex LOC OBJ [ARGNAM])(error-rational LOC OBJ [ARGNAM])(error-exact LOC OBJ [ARGNAM])(error-inexact LOC OBJ [ARGNAM])

error-number

error-positive-number

error-non-positive-number

error-natural-number

error-negative-number

error-non-positive-number

(import (type-errors-numbers number))

(error-number LOC OBJ [ARGNAM])(error-positive-number LOC OBJ [ARGNAM])(error-non-positive-number LOC OBJ [ARGNAM])(error-natural-number LOC OBJ [ARGNAM])(error-negative-number LOC OBJ [ARGNAM])(error-non-positive-number LOC OBJ [ARGNAM])

error-integer

error-positive-integer

error-non-positive-integer

error-natural-integer

error-negative-integer

error-non-positive-integer

(import (type-errors-numbers integer))

(error-integer LOC OBJ [ARGNAM])(error-positive-integer LOC OBJ [ARGNAM])(error-non-positive-integer LOC OBJ [ARGNAM])(error-natural-integer LOC OBJ [ARGNAM])(error-negative-integer LOC OBJ [ARGNAM])(error-non-positive-integer LOC OBJ [ARGNAM])

error-fixnum

error-positive-fixnum

error-non-positive-fixnum

error-natural-fixnum

error-negative-fixnum

error-non-positive-fixnum

(import (type-errors-numbers fixnum))

(error-fixnum LOC OBJ [ARGNAM])(error-positive-fixnum LOC OBJ [ARGNAM])(error-non-positive-fixnum LOC OBJ [ARGNAM])(error-natural-fixnum LOC OBJ [ARGNAM])(error-negative-fixnum LOC OBJ [ARGNAM])(error-non-positive-fixnum LOC OBJ [ARGNAM])

error-bignum

error-positive-bignum

error-non-positive-bignum

error-negative-bignum

error-non-positive-bignum

(import (type-errors-numbers bignum))

(error-bignum LOC OBJ [ARGNAM])(error-non-positive-bignum LOC OBJ [ARGNAM])(error-natural-bignum LOC OBJ [ARGNAM])(error-negative-bignum LOC OBJ [ARGNAM])(error-non-positive-bignum LOC OBJ [ARGNAM])

error-ratnum

error-positive-ratnum

error-non-positive-ratnum

error-negative-ratnum

error-non-positive-ratnum

(import (type-errors-numbers ratnum))

(error-ratnum LOC OBJ [ARGNAM])(error-non-positive-ratnum LOC OBJ [ARGNAM])(error-positive-ratnum LOC OBJ [ARGNAM])(error-negative-ratnum LOC OBJ [ARGNAM])(error-non-positive-ratnum LOC OBJ [ARGNAM])

error-float

error-flonum

error-positive-flonum

error-non-positive-flonum

error-negative-flonum

error-non-positive-flonum

(import (type-errors-numbers flonum))

(error-flonum LOC OBJ [ARGNAM])(error-float LOC OBJ [ARGNAM])(error-non-positive-flonum LOC OBJ [ARGNAM])(error-positive-flonum LOC OBJ [ARGNAM])(error-negative-flonum LOC OBJ [ARGNAM])(error-non-positive-flonum LOC OBJ [ARGNAM])

error-cplxnum

(import (type-errors-numbers cplxnum))

[procedure] (error-cplxnum LOC OBJ [ARGNAM])

Type Errors Numbers Interval

Usage

(import (type-errors-numbers interval))

error-range

[procedure] (error-range LOC START END [ARGNAM])

error-open-interval

[procedure] (error-open-interval LOC NUM MINNUM MAXNUM [ARGNAM])

error-closed-interval

[procedure] (error-closed-interval LOC NUM MINNUM MAXNUM [ARGNAM])

error-half-open-interval

[procedure] (error-half-open-interval LOC NUM MINNUM MAXNUM [ARGNAM])

error-half-closed-interval

[procedure] (error-half-closed-interval LOC NUM MINNUM MAXNUM [ARGNAM])

error-interval

[procedure] (error-interval LOC NUM LEFT MINNUM MAXNUM RIGHT [ARGNAM])

LEFT: character that denotes the symbolic opening of an interval.
RIGHT: character that denotes the symbolic closing of an interval.

Type Errors Structured

Usage

(import type-errors-structured)

error-procedure

[procedure] (error-procedure LOC OBJ [ARGNAM])

error-input-port

[procedure] (error-input-port LOC OBJ [ARGNAM])

error-output-port

[procedure] (error-output-port LOC OBJ [ARGNAM])

error-list

[procedure] (error-list LOC OBJ [ARGNAM])

error-alist

[procedure] (error-alist LOC OBJ [ARGNAM])

error-plist

[procedure] (error-plist LOC OBJ [ARGNAM])

error-pair

[procedure] (error-pair LOC OBJ [ARGNAM])

error-bytevector

[procedure] (error-bytevector LOC OBJ [ARGNAM])

error-vector

[procedure] (error-vector LOC OBJ [ARGNAM])

error-structure

[procedure] (error-structure LOC OBJ TAG [ARGNAM])

error-record and error-record-type are essentially synonyms.

error-string

[procedure] (error-string LOC OBJ [ARGNAM])

Type Errors Atoms

Usage

(import type-errors-atoms)

error-symbol

[procedure] (error-symbol LOC OBJ [ARGNAM])

error-keyword

[procedure] (error-keyword LOC OBJ [ARGNAM])

error-char

[procedure] (error-char LOC OBJ [ARGNAM])

error-boolean

[procedure] (error-boolean LOC OBJ [ARGNAM])

Type Errors SRFI-4

Usage

(import srfi-4-errors)

error-s8vector

error-u8vector

error-s16vector

error-u16vector

error-s32vector

error-u32vector

error-s64vector

error-u64vector

error-f32vector

error-f64vector

(error-s8vector LOC OBJ [ARGNAM])(error-u8vector LOC OBJ [ARGNAM])(error-s16vector LOC OBJ [ARGNAM])(error-u16vector LOC OBJ [ARGNAM])(error-s32vector LOC OBJ [ARGNAM])(error-u32vector LOC OBJ [ARGNAM])(error-s64vector LOC OBJ [ARGNAM])(error-u64vector LOC OBJ [ARGNAM])(error-f32vector LOC OBJ [ARGNAM])(error-f64vector LOC OBJ [ARGNAM])

Type Checks System

Does not allow invalid argument name specification.

Usage

(import (check-errors sys))

Note that the extension is provided as an inline. An -unsafe compile can remove the checks!

check-list

check-pair

check-vector

check-boolean

check-char

check-exact

check-inexact

check-number

check-integer

check-real

check-fixnum

check-string

check-symbol

check-keyword

check-output-port

check-input-port

check-locative

check-closure

check-procedure

check-bytevector

check-structure

check-exact-integer

check-exact-unsigned-integer

check-fixnum-in-range

(check-list LOC OBJ) -> list(check-pair LOC OBJ) -> pair(check-vector LOC OBJ) -> vector(check-boolean LOC OBJ) -> boolean(check-char LOC OBJ) -> char(check-exact LOC OBJ) -> number(check-inexact LOC OBJ) -> number(check-number LOC OBJ) -> number(check-integer LOC OBJ) -> integer(check-real LOC OBJ) -> (or integer ratnum float)(check-fixnum LOC OBJ) -> fixnum(check-string LOC OBJ) -> string(check-symbol LOC OBJ) -> symbol(check-keyword LOC OBJ) -> keyword(check-output-port LOC OBJ) -> output-port(check-input-port LOC OBJ) -> input-port(check-locative LOC OBJ) -> locative(check-closure LOC OBJ) -> procedure(check-procedure LOC OBJ) -> procedure(check-bytevector LOC OBJ) -> bytevector(check-structure LOC OBJ TAG) -> (struct TAG)(check-exact-integer LOC OBJ) -> integer(check-exact-unsigned-integer LOC OBJ) -> integer(check-fixnum-in-range LOC OBJ LOW HIGH)-> fixnum)

Notes

While a LOC is often enough to distinguish arguments of different expected types, an ARGNAM should be supplied otherwise.

;describes a #!key argument
(check-symbol 'v-op oper #:operation)

;more descriptive (and specific)
(check-integer 'v-op x "x coordinate")
(check-integer 'v-op y "y coordinate")

Assuming predicates are available for all used types then checks can be made using only define-check+error-type, reducing the runtime dependencies.

(import (check-errors basic))
(define-check+error-type my-type)

If a module/library only uses system types & doesn't need (having disjoint types), or want, argument disambiguation by name then (import (check-errors sys)).

(define (func x a y b)
  (baz (check-exact 'func x) (check-inexact 'func y))
  (bar (check-symbol 'func a) (check-string 'func b))
  ...)

While check-float is not check-inexact, this will work; However still an inexact message:

(import (check-errors sys) miscmacros)
(define-syntax-rule (check-float . ?args) (check-inexact . ?args))

If "-strict-types" are important for you then be sure to import from the libraries with a compiled types annotation file. CHICKEN doesn't "roll-up" the type annotations so the compiler will miss them unless the actual exporting module is specified, and not an omnibus module.
The (check-...) procedure will return the checked object so replacing the 1st argument variable reference with the check form will save a fetch.

(define (func x y)
  (foo (bar (baz (check-Tx 'func x 'x) (check-Ty 'func y 'y)))) )

(define (func x y)
  (let* ((bazle (baz (check-Tx 'func x 'x) (check-Ty 'func y 'y)))
         (...uses bazle, x, y...) )
  ...) )

- Any reliance on execution order is undefined!

(func (check-Tx 'func x 'x) 42 (op x)) ;<loud buzzer sound>

   ;* missing?
(let ((a (foo (check-Tx 'func x 'x)))  ;<loud buzzer sound>
      (b (op x)) )
  ...)

Bugs & Limitations

The make-*-message functions are English only; but pluggable, given the source. See "type-errors-en.incl.scm" & "type-errors-basic.scm".

Author

Kon Lovett

Repository

This egg is hosted on the CHICKEN Subversion repository:

https://anonymous@code.call-cc.org/svn/chicken-eggs/release/5/check-errors

If you want to check out the source code repository of this egg and you are not familiar with Subversion, see this page.

Version history

4.0.1 ; Remove unavailable.
4.0.0 ; CHICKEN 6 release.

License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the Software), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ASIS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.